Studi Kasus: Mengubah string 2 menjadi object Dua(4)

Mengubah string 2 menjadi object Dua.

Sekarang kita akan mencoba jika inputnya 2. Berikut ini adalah testnya,

[Test] 
public void Konversi2KeObjectDua() 
{ 
	string input="2"; 
	IExpressionConverter exConverter=new ExpressionConverter(); 
	Assert.IsInstanceOfType(typeof(IExpression),exConverter.Convert(input)); 
	Assert.AreEqual("2",exConverter.Convert(input).Expression); 
}

NUnit memberikan pesan,

	Expected:”2”
	But was  :”1”

Untuk “make it work” kita harus mengubah implementasi method Convert. Method ini harus bisa membedakan kedua input. Kita coba menggunakan switch-case,

public IExpression Convert (string expresi) 
{ 
	switch (expresi) { 
	 case "1": 
		return new Satu(); 
	 case "2": 
		return new Dua(); 
	default: 
		return null; 
	} 
}

Output method Convert yang sebelumnya Satu saya ubah menjadi IExpression. Dengan demikian class Dua juga harus mengimplementasikan IExpression. Selain itu interface IexpressionConverter juga berubah menjadi,

public interface IExpressionConverter 
{ 
	IExpression Convert(string expresi); 
}

dan class Dua,

public class Dua:IExpression 
{ 
		 
	public Dua() 
	{ 
	} 
	public string Expression{ 
		get { 
			return "2"; 
		} 
	} 
}

Property Expression harus kita definisikan juga didalam interface IExpression,

public interface IExpression 
{ 
	string Expression {get;} 
}

Ok. untuk 1 dan 2 done.

Untuk 3 sampai 9 kurang lebih sama, jadi saya tidak akan ulas disini. Pada akhirnya method Convert menjadi,

public IExpression Convert (string expresi) 
{ 
	switch (expresi) { 
	 case "1": 
		return new Satu(); 
	 case "2": 
		return new Dua(); 
	 case "3": 
		return new Tiga(); 
	 case "4": 
		return new Empat(); 
	 case "5": 
		return new Lima(); 
	 case "6": 
		return new Enam(); 
	 case "7": 
		return new Tujuh(); 
	 case "8": 
		return new Delapan(); 
	 case "9": 
		return new Sembilan(); 
	case "0": 
		return new Nol(); 
	default: 
		return null; 
	} 
}

Hanya merupapkan kumpulan konstruktor. Dan perbedaan antara class yang dikonstruksi hanya terletak pada property Expression. Property ini seharusnya bisa kita supply lewat konstruktor. Katakanlah saya buat class Number, sehingga untuk object Satu bisa diwakili dengna konstruksi new Number(1).

[Test] 
public void Number() 
{ 
	IExpression ex=new Number(1); 
	Assert.AreEqual("1",ex.Expression); 
}

Agar test bisa dikompilasi cukup kita buat implementasi number

public class Number:IExpression 
{ 
	public Number(int number) 
	{ 
	} 
	public string Expression{ 
		get { 
			return ""; 
		} 
	} 
}

NUnit sekarang menjadi merah. Untuk merubah NUnit menjadi hijau ada dua cara, pertama kita langsung mereturn “1” atau kita membuat implementasi langsung. Karena impelemantasinya cukup jelas, saya pilih no dua. Sehingga,

public class Number:IExpression 
{ 
	private int m_number; 
	public Number(int number) 
	{ 
		m_number=number; 
	} 
	public string Expression{ 
		get { 
			return this.m_number.ToString(); 
		} 
	} 
}

Test saya jalankan dan hijau.

Ok. Sekarang kita ganti implementasi Convert menjadi,

public IExpression Convert (string expresi) 
{ 
	switch (expresi) { 
	 case "1": 
		return new Number(1); 
	 case "2": 
		return new Number(2); 
	 case "3": 
		return new Number(3); 
	 case "4": 
		return new Number(4); 
	 case "5": 
		return new Number(5); 
	 case "6": 
		return new Number(6); 
	 case "7": 
		return new Number(7); 
	 case "8": 
		return new Number(8); 
	 case "9": 
		return new Number(9); 
	case "0": 
		return new Number(0); 
	default: 
		return null; 
	} 
}

Dan semua class Satu sampai Sembilan boleh kita hapus. Hah…capek-capek dibikin kok dihapus….

Karena hanya berisi konstruksi object, maka akan lebih baik jika kita pindahkan saja ke class Number sebagai factory. Dan kontruksi Number kita buat private.

public IExpression Convert (string ekspresi) 
{ 
	return Number.CreateNewNumber(ekspresi); 
}

Dan class Number,

public class Number:IExpression 
{ 
	private int m_number; 
	private Number(int number) 
	{ 
		m_number=number; 
	} 
	public string Expression{ 
		get { 
			return this.m_number.ToString(); 
		} 
	} 
	public static IExpression CreateNewNumber(string ekspresi) 
	{ 
		switch (ekspresi) { 
		 case "1": 
			return new Number(1); 
		 case "2": 
			return new Number(2); 
		 case "3": 
			return new Number(3); 
		 case "4": 
			return new Number(4); 
		 case "5": 
			return new Number(5); 
		 case "6": 
			return new Number(6); 
		 case "7": 
			return new Number(7); 
		 case "8": 
			return new Number(8); 
		 case "9": 
			return new Number(9); 
		case "0": 
			return new Number(0); 
		default: 
			return null; 
		} 
	} 
}

Serta salah satu test kita, Number juga harus kita ubah, karena tidak bisa lagi create secara langsung

[Test] 
public void NumberTest() 
{ 
	IExpression ex=Number.CreateNewNumber("1"); 
	Assert.AreEqual("1",ex.Expression); 
}

Perhatikan bagaimana perubahan-perubahan kita lakukan secara radikal dan besar-besaran, tetapi kita tidak merasa takut akan terjadi sesuatu. Mengapa? Karena kita yakin jika terjadi sesuatu akan ketahuan disisi test. Itulah salah satu kegunaan test.

Sejauh ini kita telah menyelesaikan bagaimana ekspresi angka kita ubah menjadi Number. Apa saja yang telah kita selesaikan? Mari kita tengok.

5+2+4-3+10-2=?

Konversi string 1 ke object Satu.

Konversi string 2 ke object Dua.

Konversi string 3 ke object Tiga.

…dst sampai Sembilan.

Object puluhan

Object ratusan

Object penjumlahan

Eksepsi jika tidak ada ekspresi yang bersesuaian

Iklan

There are no comments on this post.

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout / Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout / Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout / Ubah )

Foto Google+

You are commenting using your Google+ account. Logout / Ubah )

Connecting to %s

%d blogger menyukai ini: