Jejaring Object

Pemprograman berorentasi object adalah teknik membuat program dengan object sebagai titik-titik perhatian. Object pada umumnya adalah wakil dari sebuah benda atau keadaan dalam sebuah sistem sesungguhnya. Namun demikian, fokus utama dari ‘berorentasi object” adalah komunikasi antar object bukan pada diri object.

Sebuah object dalam berkomunikasi menerima pesan dari object lain dan kemudian menjawab pesan itu dengan memberikan pesan pada object lain atau mengembalikan sebuah nilai atau malah mungkin pesan error pada object pengirim pesan. Kirim mengirim pesan ini dalam sebuah object diwakili oleh perintah yang diberinama “Method”. Didalam method inilah pesan kemudian diterjemahkan, state diubah, pesan ke object lain dipanggil dan lain sebagainya.

Dalam sebuah system berorentasi object, object-object tersusun dan terhubung seperti jaring, sedemikian hingga object-object saling bisa berkomunikasi. Perilaku dari system seperti ini tergantung pada pilihan object yang disusun. Sekali seubah object didalam sistem diganti, maka perilaku dari sistem itu juga berubah.

Jejaring Objects

Gambar. Jejaring Object

Karena perilaku dari sebuah sistem dapat kita ubah-ubah hanya dengan mengganti object, dengan demikian untuk mengatur object-object kita cukup mendeklarasikan saja. Artinya kita hanya fokus pada apa yang akan dilakukan object bukan pada bagaimana sebuah pesan dikerjakan.

Tell Don’t Ask

Ok. Object-object sekarang sudah saling terhubung, bagaimana sih sesungguhnya mereka berkomunikasi? Dalam berkomunikasi object akan mendeskrispsikan apa yang diinginkannya pada object lain, tentu saja sesuai dengan aturan dari object lain itu. Sesuai tugasnya object lain tersebut kemudian melaksanakan apa yang diperintahkan.

Alec Sharp dalam bukunya Smalltalk by Example, mengatakan:

Procedural code gets information then makes decisions. Object-oriented code tells objects to do things.
— Alec Sharp

Cara berkomunikasi seperti ini umumnya disebut sebagai model “tell don’t ask”, yang merupakan hukum Demeter. Tell berarti object memerintahkan object lain untuk melakukan sesuatu–sesuai rule-nya tentu. Sedangkan ask berarti object meminta state object lain dan berdasarkan state itu object memutuskan sesuatu terhadap object lain. Maksudnya, daripada mengquery state sebuah object, yang bisa jadi nanti malah kehilangan makna, lebih baik langsung memerintahkan object lain itu. Biarkan object lain memutuskan sendiri apa yang harus dilakukan berdasarkan state yang dia punyai.

Berdasarkan hukum Demeter, method dalam sebuah object hanya boleh memanggil hal-hal yang dimiliki oleh:

• object itu sendiri.
• parameter-parameter yang dikirim melalui method tersebut.
• object-object yang dicreate oleh object itu sendiri.
• komposisi object.

Mengikuti hukum ini, perubahan terhadap sebuah object tidak akan mempengaruhi object lain, dengan demikian tercapailah tujuan agar memanage object-object itu cukup dengan “declaratif”. Jadi hukum ini akan membuat object-object tidak saling tergantung.

Nat dan Steve memberikan contoh dalam bukunya, Growing Object-Oriented Software, Guided by Tests,
mengenai apa yang akan terjadi jika kita tidak mengikuti hukum ini, mereka menyebutnya “train wreck code“, kereta yang celaka:

((EditSaveCustomizer) master.getModelisable()
  .getDockablePanel()
    .getCustomizer())
      .getSaveItem().setEnabled(Boolean.FALSE.booleanValue());

Setelah dipikir sejenak mengikuti hukum Demeter, maka code ini seharusnya:

master.allowSavingOfCustomisations();

Jadi pemanggilan yang mirip rangkain kereta itu cukup diwrap dalam satu method yang bisa dimengerti saja. Sebagai pengguna object master, kita tidak perlu tahu apa yang diperbuat oleh object master.

Tentu, tidak semua kita “tell” ada beberapa hal yang tetep harus kita “ask”, seperti jika kita berhubungan dengan Value Object, Collection, dan juga dataset.

Object Unit Testing

Mengisolasi Object

Lantas bagaimana melakukan unit test agar state dari sebuah object tidak terekspose keluar? Pertama-tama object harus kita isolasi. Kembali pada gambar yang dibuat oleh Nat dan Steve, object in isolation, salah satu object, yang dilingkari merah, menerima pesan dari dua object dan megirim pesan ke tiga object disekitarnya. Kelima object penerima dan pengirim pesan akan kita singkirkan dan tinggallah satu object dalam lingkaran merah.

how to test one object

menjadi,

.

Mock Objects

Kalau kawan-kawannya kita singkirkan, lalu kawan-kawannya kita ganti dengan apa? Kita akan ganti dengan mock atau stub atau apalah yang jelas bukan object sebenarnya. Pada saat melakukan test class-class pembentuk object sebenarnya juga tidak harus ada, cukup diwakili oleh sebuah interface yang menggambarkan apa tugas object yang diwakilinya. Dengan cara seperti ini sebetulnya pada saat yang sama kita juga sedang mencari bentuk object seperti apa yang bisa  mewakili.—lebih jauh kita akan bahas dengan sebuah contoh(MVC Calculator).

Mocking Object

Lantas jika object-object disekitarnya tidak ada, bagaimana kolaborasi itu bisa dilaksanakan? Caranya adalah dengan mengganti object-object tadi dengan object Mock. Apa yang dikerjakan Mock? Sebagai wakil dari object sesungguhnya, Mock akan mengeluarkan kemampuan yang  diinginkan test atau disebut Expectation. Jadi setiap kali sebuah object yang kita test membutuhkan respon dari object lain, maka kita tambahkan Expectation didalam Mock. Sekali lagi saya gunakan gambar Nat dan Steve:

Mockery adalah factory dari object-object yang kita mock. Apa yang kita mock? Yang kita mock adalah interface.

Berikut ini adalah langkah-langkah membuat test (khusus untuk object-object yang sudah jelas):

1. Mock semua object yang dibutuhkan (object-object disekitar).
2. Buat object yang akan ditest (kongkrit object).
3. Setup semua Expectation yang diinginkan.
4. Triger event dari object yang ditest.
5. Uji semua yang hendak ditest dan cek semua ekspektasi telah dipenuhi.

Ini adalah urutan jika kita sudah tahu semua yang terlibat. Jika belum, saya biasanya bergerak dari bawah keatas (5–>4–>3–>2–>1).

Kita akan bahas lebih lanjut mengenai mock dengan contoh.

Eksepsi

Test berikut ini bertujuan untuk mengantisipasi agar user tidak memasukkan huruf.

[Test]
[ExpectedException(typeof(ApplicationException),"Expression A not supported")]
public void EksepsiMasukanBentukHuruf()
{
	string input="100 - 2A0 + 1 - 10";
	IExpressionConverter exConverter=new ExpressionConverter();
	exConverter.Convert(input);
}

Jadi jika didalam ekspresi ada huruf, converter akan menthrow exception.

Ratusan

Ratusan adalah komposisi puluhan, tunggal dan ratusan itu sendiri.

Gambar. Komposisi Ratusan.

Untuk membentuk ratusan, terlebih dahulu kita harus membangun komposisi puluhan. Berikut ini adalah test untuk membentuk komposisi ratusan.

[Test]
public void MembuatKomposisiRatusan()
{
	IExpression dua=Number.CreateNewNumber("2");
	IExpression nol=Number.CreateNewNumber("0");
	IExpression duaNol=new Puluhan(dua,nol);
	IExpression nol2=Number.CreateNewNumber("0");
	IExpression ratusan=new Ratusan(duanol,nol2);
	Assert.AreEqual("200",ratusan.Expression);
}

Mencontek puluhan kita bisa mendapatkan calss Ratusan,

public class Ratusan:IExpression
{
	private IExpression m_puluhan;
	private IExpression m_ratusan;
	public Ratusan(IExpression ratusan, IExpression puluhan)
	{
		this.m_puluhan=puluhan;
		this.m_ratusan=ratusan;
	}
	public string Expression{
		get{
			return this.m_ratusan.Expression + this.m_puluhan.Expression;
		}
	}
	public object Value {
		get {
			return (int)this.m_ratusan.Value * 100 + (int)this.m_puluhan.Value;
		}
	}
}

Tidak memerlukan red, implementasi ini langsung membuat test kita menjadi hijau.

Berikutnya kita buat test untuk ekspresi,

[Test]
public void Konversi121KeRatusan()
{
	string input="121";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("121",ex.Expression);
	Assert.AreEqual(121,ex.Value);
}

Pesan dari test: Expression 121 not supported.

Seperti dapat diduga kita belum mensupport ratusan didalam method Number.CreateNewNumber. Untuk itu method ini kita ubah menjadi,

public static IExpression CreateNewNumber(string ekspresi)
{
	if(ekspresi.Length==1)
		return createSingleNumber(ekspresi);
	else if(ekspresi.Length==2)
		return createPuluhan(ekspresi);
	else if(ekspresi.Length==3)
		return createRatusan(ekspresi);
	else
		throw new ApplicationException(String.Format("Expression {0} not supported",ekspresi)); 

}

Jadi kita tambahkan blok if ketiga untuk menghandle string yang panjangnya 3 karakter. Kemudian method createRatusan kita definisikan sebagai berikut:

private static IExpression createRatusan(string ekspresi)
{
	char[] exs=ekspresi.ToCharArray();
	IExpression ratusan=Number.CreateNewNumber(exs[0].ToString());
	IExpression puluhan=createPuluhan(String.Format("{0}{1}",exs[1],exs[2]));
	return new Ratusan(ratusan,puluhan);
}

Yaitu cukup dengan mengambil karakter pertama sebagai ratusan dan karakter sisanya sebagai puluhan. Impelementasi ini cukup membuat test kita memberi warna hijau, sehingga kita bisa melangkah menuju test selanjutnya.

Berikutnya adalah test penjumlahan 100 + 100,

[Test]
public void Penjumlahan100dengan100()
{
	string input="100 + 100";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("100 + 100",ex.Expression);
	Assert.AreEqual(200,ex.Value);
}

Test ini juga lewat.

Beriktunya test penjumlahan 100 + 20 + 1,

[Test]
public void Penjumlahan100dengan20dengan1()
{
	string input="100 + 20 + 1";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("100 + 20 + 1",ex.Expression);
	Assert.AreEqual(121,ex.Value);
}
	<p>Test ini juga lewat.</p>
	<p>Berikutnya test penjumlahan dan pengurangan 100-20+1-10,</p>
[sourcecode language='csharp']
[Test]
public void PenjumlahanDanPengurangan100dengan20dengan1()
{
	string input="100 - 20 + 1 - 10";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("100 - 20 + 1 - 10",ex.Expression);
	Assert.AreEqual(71,ex.Value);
}

Ini juga lewat.

Tujuan utama kita

Eksepsi jika tidak ada ekspresi yang bersesuaian

Minus telah kita selesaikan dengan baik. Sekarang bagaimana dengan tujuan pertama kita :5+2+4-3+10-2=?

Tidak ada cara lain kecuali mencobanya,

[Test]
public void PenjumlahanDanPengurangan()
{
	string input="5+2+4-3+10-2";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("5 + 2 + 4 - 3 + 10 - 2",ex.Expression);
	Assert.AreEqual(16,ex.Value);
}

Sekali lagi tidak ada yang perlu diubah. Semuanya green.

Masih ada dua task tersisa. Ratusan dan eksepsi-eksepsi. Ratusan kaitannya dengan bagaimana kita membuat mehod CreateNewNumber. Sedangkan eksepsi katiannya dengan input-input yang salah dimasukkan oleh user, huruf misalnya.

Minus

Penjumlahan telah kita selesaikan dengan baik. Untuk pengurangan pastinya lebih mudah. Pertama-tama kita harus membuat komposisi dari operasi minus. Mencontek dari test komposisi plus, berikut ini adalah test untuk komposisi minus.

[Test]
public void KomposisiMinus()
{
	IExpression puluhan=Number.CreateNewNumber("2");
	IExpression satuan=Number.CreateNewNumber("0");
	IExpression asal=new Puluhan(puluhan,satuan);
	IExpression pengurang=Number.CreateNewNumber("1");
	IExpression minus=new Minus(asal, tambahan);
	Assert.AreEqual("20 - 1",minus.Expression);
	Assert.AreEqual(19,minus.Value);
}

Disini kita ingin mengurangi 1 dari 20. Agar test bisa dikompile kita harus membuat class Minus. Mencontek dari class Plus, test diatas langsung green.

public class Minus:IExpression
{
	private IExpression m_asal;
	private IExpression m_pengurang;
	public Minus(IExpression asal, IExpression pengurang)
	{
		this.m_asal= asal;
		this.m_pengurang = pengurang;
	}
	public string Expression {
		get {
			return String.Format("{0} - {1}",this.m_asal.Expression,this.m_pengurang.Expression);
		}
	}
	public object Value {
		get {
			return (int)this.m_asal.Value - (int)this.m_pengurang.Value;
		}
	}
}

Langkah berikutnya adalah membangun ekspresi minus, jadi kita harus bisa mengkonversi “20 -1”. Berikut ini adalah test hasil contekan dari test ekspresi plus.

[Test]
public void EkspresiMinus(){
	string input="1 - 1";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("1 - 1",ex.Expression);
	Assert.AreEqual(0,ex.Value);
}

Pesan yang muncul : Expression – not supported. Good! Memang minus belum kita support. Todo that…. gampang tambahkan sesuatu di method getOperator.

private IExpression getOperator(string ekspresi,IExpression exp1, IExpression exp2)
{
	int oprIndex=getOperatorPosition(1,ekspresi);
	string opr=ekspresi.Substring(oprIndex,1); 

	if(opr.Equals(PLUS.ToString()))
		return new Plus(exp1,exp2);
	else if(opr.Equals(MINUS.ToString()))
		return new Minus(exp1,exp2);
	else
		throw new ApplicationException(String.Format("Expression {0} not operator",opr));
}

Perhatikan blok kedua dari if. Sesimpel itu. Semua test kita menjadi green. Bagaiman dengan 20-1 dan 1-20? Ok. Mari kita buat test,

public void Kurangkan1dari20(){
	string input="20 - 1";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("20 - 1",ex.Expression);
	Assert.AreEqual(19,ex.Value);
}

[Test]
public void Kurangkan20dari1(){
	string input="1 - 20";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("1 - 20",ex.Expression);
	Assert.AreEqual(-19,ex.Value);
}

Tak ada yang perlu diaubah, semuanya green. Bagaimaan dengan 10-20-30-40-51? Ayo kita buat testnya,

[Test]
public void OperatorMinusLebihDari3(){
	string input="10 - 20 - 30 - 40 - 51";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("10 - 20 - 30 - 40 - 51",ex.Expression);
	Assert.AreEqual(-131,ex.Value);
}

Tetap OK. Tidak ada masalah. Kita coret task kita.

Penjumlahan 20 + 30

Sebelum melangkah lebih jauh kita harus menguji apakah ekspresi ke dua bisa menerima puluhan. Berikut ini adalah contoh test untuk hal ini,

[Test]
public void Penjumlahan20dengan30(){
	string input="20 + 30";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("20 + 30",ex.Expression);
	Assert.AreEqual(50,ex.Value);
}

Good! Test kita bisa jalan. Dengan demikian puluhan di ekspresi kedua bisa diterima.

Sampai disini sebetulnya kita telah melangkah 75% sisa yang 25% hanyalah perulangan. 1+1+1 boleh kita tulis ([1+1] + 1). Kunci dari keberhasilan konversi kita selanjutnya terletak pada seberapa pintar kita melakukan pemotongan. Daripada banyak teori, kita langsung test saja,

[Test]
public void Penjumlahan1dengan1dengan1(){
	string input="1 + 1 + 1";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("1 + 1 + 1",ex.Expression);
	Assert.AreEqual(3,ex.Value);
}

Test ini berakhir red, dengan pesan: expected “1 + 1 + 1” but was “1 + 1”. Dengan demikian kita sebetulnya telah mengenali pola pertama kita tinggal mengulang lagi pola yang kedua. Caranya adalah dengan mengetahui letak atau posisi masing-masing operator. Nah, kita melakukan looping didalam string dan memotong-motongnya. Kita melakukan loop sebanyak operator yang ada. Tantangannya adalah kita harus tahu jumlah operator dan juga posisi. Jumlah operator adalah sebanyak jumlah number dikurang satu: opr=angka -1. Untuk sementara test kita diatas kita ignore. Kita akan mencoba melakukan pencarian jumlah operator dan posisi terlebih dahulu.

Berikut ini adalah test untuk mencari jumlah operator,

[Test]
public void HitungJumlahOperator()
{
	string input="1 + 1 + 1 - 5 -60 + 10";
	string[] opr=input.Split('+','-');
	Assert.AreEqual(5,opr.Length-1);
}

Dengan demikian untuk mengetahui jumlah operator kita gunakan method Split().

Dan berikut ini adalah test method untuk mendapatkan posisi dari operator,

[Test]
public void DapatkanPosisiOperatorDalamExpresi()
{
	string input="1 + 1 + 1 - 5 -60 + 10";
	Assert.AreEqual(2,getOperatorPosition(1,input));
	Assert.AreEqual(6,getOperatorPosition(2,input));
	Assert.AreEqual(10,getOperatorPosition(3,input));
	Assert.AreEqual(14,getOperatorPosition(4,input));
}

Jadi kita harus mensupplay nomor operator dan ekspresi input.

private int getOperatorPosition(int number,string input)
{
	string[] opr=input.Split('+','-');
	int result=0;
	for(int i=0; i<number;i++)
	{
		result +=opr[i].Length;
	}
	result +=number-1;
	return result;
}

Sekalilagi kita menggunakan split. Lalu kita susun sebanyak operator yang diinginkan. Apa yang kita dapatkan disini akan kita terapkan di program.

Sekarang hapus Ignore dan kembali ke test sebelumnya. Lalu saya rubah method interpret menjadi,

private IExpression interpret(string ekspresi)
{
	ekspresi=ekspresi.Trim();
	ekspresi=ekspresi.Trim(PLUS,MINUS);
	if(!(ekspresi.Contains(PLUS.ToString())||ekspresi.Contains(MINUS.ToString())))
		return Number.CreateNewNumber(ekspresi);
	else{
		int totalOperator=getTotalOperator(ekspresi);
		IExpression exp1=getExp1(ekspresi);
		string subEkspresi=ekspresi;
		for(int i=0;i<totalOperator;i++){
			exp1=composeOperation(exp1,subEkspresi);
			subEkspresi=getNextExpression(i+1,ekspresi);
		}
		return exp1;
	}
}

Pertama, saya harus mendapatkan jumlah operator didalam ekspresi. Cara untuk mendapatkannya sudah kita riset sebelumnya.

Kedua, saya harus mendapatkan ekspresi 1 (exp1). Jadi untuk ekspresi “5+4+1+3” perulangannya akan seperti ini.

Langkah 1: exp1=5. Exp2=4. Operator=+. SubEkspresi=”5+4+1+3”
Langkah 2: exp1=5+4. Exp2=1 Operator=+. SubEkspresi=”4+1+3”
Langkah 3: exp1=5+4+1. Exp2=3 Operator=+. SubEkspresi=”1+3”

Perhatikan disini ada perubahan dari string menjadi komposisi. Exp1 adalah komposisi yang selalu kita suntikkan sebagai pembentuk komposisi berikutnya.

Method getNextExpression saya maksudkan untuk menapatkan ekspresi berikutnya yang akan saya suntikkan ke dalam komposisi.

private int getTotalOperator(string ekspresi)
{
	string[] opr=ekspresi.Split(PLUS,MINUS);
	return opr.Length-1;
}

Perhatikan, getTotalOperator sama persis dengan yang ada didalam test. Jadi, saya akan membuat test semua asumsi yang tidak jelas dalam kepala saya menjadi code yang lebih jelas. Hasilnya bisa langsung kita kopikan. Ini lebih aman dari pada saya buat didalam program.

Untuk kasus seperti ini biasanya para pengguna IDE melakukan debugging dengan melihat apa hasilnya didalam IDE pada saat program dirun. Disini kita hanya menukil sebagian kecil dari fungsi yang kita inginkan.

private string getNextExpression(int next,string ekspresi)
{
	int oprIndex=getOperatorPosition(next,ekspresi);
	return ekspresi.Substring(oprIndex+1);
}

Method getNextExpression saya masksudkan untuk mendapatkan ekspresi berikutnya (subekspresi) seperti yang telah saya jelaskan diatas. Jadi saya harus mendapatkan index ke-n dari operator tersebut. Dari situ kemudian dipotong sampai ke belakang.

private int getOperatorPosition(int number,string input)
{
	string[] opr=input.Split(PLUS,MINUS);
	int result=0;
	for(int i=0; i<number;i++)
	{
		result +=opr[i].Length;
	}
	result +=number-1;
	return result;
}

Perhatikan, sama persis dengan yang kita riset.

Nah, bagaimana dengan komposisi,

private IExpression composeOperation(IExpression exp1,string ekspresi)
{
	IExpression exp2=getExp2(ekspresi);
	return getOperator(ekspresi,exp1,exp2);
}

Ternyata sederhana saja dan merupakan kopian dari code sebelumnya he he he. Jadi sebetulnya saya hanya memotong bagian yang mesti diulang-ulang. Itu saja.

Sekarang kita jalankan test. Ups!! Pesan kesalahannya : Expression 0 not operator.

Pesan ini mengindikasikan kegagalan untuk mendapatkan operator. Sayangnya tidak jelas operataor keberapa. Buntu.

Para newbie dalam TDD biasanya akan membuat applikasi konsole, lalu membuat method Main(). Membuat code yang bersesuaian didalam Main. Menandaiknya dengan tanda merah. Kemudian menjalankan program. Ketika tanda kuning sudah jatuh didalam tanda merah. Kursor mouse diarahkan disalah satu variabel kemudian dilihat value-nya. Setelah itu ambil keputusan. Diubah dan diulang lagi.

Saya tidak akan mengajarkan seperti itu. Saya lebih suka meletakkan Console.Writeline() kemudian melihat hasilnya di console NUnit. Setelah semuanya selesai, Console.Writeline itu akan saya hapus.

Jadi saya akan letakkan Console.WriteLine didalam method getOperator,

private IExpression getOperator(string ekspresi,IExpression exp1, IExpression exp2)
{
	string afterExp1=ekspresi.Substring(exp1.Expression.Length).Trim();
	Console.WriteLine("exp1 {0}, exp2 {1}, ekspresi {2}, afterExp1 {3}",
	                  exp1.Expression,exp2.Expression,ekspresi,afterExp1);
	string opr=afterExp1.Substring(0,1);
	if(opr.Equals(PLUS.ToString())){
		return new Plus(exp1,exp2);
	}else
		throw new ApplicationException(String.Format("Expression {0} not operator",opr));
}

Output dari console ini adalah:

	exp1 10, exp2 20, ekspresi 10 + 20 + 30 + 40 + 51, afterExp1 + 20 + 30 + 40 + 51
	exp1 10 + 20, exp2 30, ekspresi  20 + 30 + 40 + 51, afterExp1 0 + 40 + 51

Dari data diatas, terlihat kita gagal dilooping kedua. Baik exp1 dan exp2 serta subekspresi sudah benar. Tetapi logika untuk mendapatkan operator berikutnya salah.

Sebelumnya, untuk mendapatkan operator kita lakukan dengan memotong subekspresi dengan ekspresi pertama sehingga harapannya afterExp1 tinggal + 30 + 40 + 51. Karena ekspresi pertama kini bukan lagi ekspresi tunggal tapi sudah komposisi, akibatnya pemotongannya terlalu panjang.

Maka, tidak ada cara lain kecuali mengubah algoritma pemotongan. Pertama, kita harus mendapatkan posisi operator pertama dalam subekspresi. Untungnya kita telah memiliki method untuk mendapatkan posisi itu. Index posisi yang dihasilkan kemudian kita pakai untuk mendapatkan operator. Jadi saya ubah menjadi,

private IExpression getOperator(string ekspresi,IExpression exp1, IExpression exp2)
{
	int oprIndex=getOperatorPosition(1,ekspresi);
	string opr=ekspresi.Substring(oprIndex,1);
	Console.WriteLine("exp1 {0}, exp2 {1}, ekspresi {2}, afterExp1 {3}",
	                  exp1.Expression,exp2.Expression,ekspresi,ekspresi.Substring(oprIndex)); 

	if(opr.Equals(PLUS.ToString())){
		return new Plus(exp1,exp2);
	}else
		throw new ApplicationException(String.Format("Expression {0} not operator",opr));
}

Perhatikan angka 1 dalam method getOperatorPosition(1,ekspresi). Jadi saya hanya ambil posisi yang pertama. Console out yang dihasilkan,

	exp1 10, exp2 20, ekspresi 10 + 20 + 30 + 40 + 51, afterExp1 + 20 + 30 + 40 + 51
	exp1 10 + 20, exp2 30, ekspresi  20 + 30 + 40 + 51, afterExp1 + 30 + 40 + 51
	exp1 10 + 20 + 30, exp2 40, ekspresi  30 + 40 + 51, afterExp1 + 40 + 51
	exp1 10 + 20 + 30 + 40, exp2 51, ekspresi  40 + 51, afterExp1 + 51

Setelah perubahan ini afterExp1 menunjukkan nilai yang benar. Jadi cukup memotong satu karakter diujung, didapatlah operator.

Console.WriteLine saya hapus. Semua test berjalan dengan benar.

Ubah + dan – dengan konstanta.

Tambahkan konstanta berikut ini kedalam class ExpressionConverter,

public class ExpressionConverter:IExpressionConverter
{
	private const char PLUS='+';
	private const char MINUS='-';
	private const string NOL="0";
	...
}

Setelah itu ubah semua magic karakter ke konstanta diatas. Sebagai contoh anda bisa lihat yang berikut ini,

private IExpression interpret(string ekspresi)
{
	ekspresi=ekspresi.Trim();
	ekspresi=ekspresi.Trim(PLUS,MINUS);
	if(!(ekspresi.Contains(PLUS.ToString())||ekspresi.Contains(MINUS.ToString())))
		return Number.CreateNewNumber(ekspresi);
	else{
		IExpression exp1=getExp1(ekspresi);
		IExpression exp2=getExp2(ekspresi);
		return getOperator(ekspresi,exp1,exp2);
	}
}

Perhatikan PLUS dan MINUS bertipe Char, jadi untuk string anda harus mengubahnya ke tipe string dengan method PLUS.ToString().

All Green.

Kita sudah separuh jalan. List kita juga semakin panjang. Ambil kertas, pindahkan yang belum dicoret. Simpan yang lama.

Panggil saja aku Interpret

Bagian pertama dan kedua dari blok if didalam method Convert, sebetulnya dimaksudkan untuk menginterpretasi jika didalam ekspresi tidak ada operator. Maka, untuk memindahkan blok ini kedalam method Interpret adalah cukup dengan memeriksa apakah didalam ekspresi ada operator + atau tidak.

private IExpression interpret(string ekspresi)
{
	ekspresi=ekspresi.Trim();
	ekspresi=ekspresi.Trim('+','-');
	if(!(ekspresi.Contains("+")||ekspresi.Contains("-")))
		return Number.CreateNewNumber(ekspresi);
	else{
		IExpression exp1=getExp1(ekspresi);
		IExpression exp2=getExp2(ekspresi);
		return getOperator(ekspresi,exp1,exp2);
	}
}

Perubahan ini tidak mempengaruhi test. NUnit tetap green. Karena itu method Convert saya ubah menjadi,

public IExpression Convert (string ekspresi)
{
	if(ekspresi.Length==1)
		return interpret(ekspresi);
	else if (ekspresi.Length == 2)
		return interpret(ekspresi);
	else if(ekspresi.Length>2)
	    return interpret(ekspresi);
	else
		return interpret(ekspresi);
}
	<p>Semua blok if memanggil method yang sama : interpret. Dengan demikian if boleh kita hilangkan,</p>
[sourcecode language='csharp']
public IExpression Convert (string ekspresi)
{
		return interpret(ekspresi);
}

Lebih sederhana dan mudah dibaca. Agar lebih mudah dibaca lagi, kia akan ganti + dan – yang bertebaran dimana-mana itu dengan enum operator.

Refactoring CreateNumber

Agar Number bisa mengcreate puluhan kita harus merubah sedikit cara mengenali ekspresi. Jika panjangnya 1, tetap dibuat seperti biasa. Jika panjangnya 2, panggil method pembuat puluhan,

public static IExpression CreateNewNumber(string ekspresi)
{
	if(ekspresi.Length==1)
		return createSingleNumber(ekspresi);
	else if(ekspresi.Length==2)
		return createPuluhan(ekspresi);
	else
		throw new ApplicationException(String.Format("Expression {0} not supported",ekspresi)); 

}

Disini createSingleNumber adalah method yang menanggil kode sebelumnya—jadi saya pindahkan agar enak dilihat. Sedangkan createPuluhan adalah method yang akan kita gunakan untuk membuat Puluhan. Isi dari method ini sebetulnya hanya mencontek yang ada di mehod Convert untuk kondisi ekspresi dengan panjang 2. Ini merupakan kandidat untuk kita refaktor nantinya karena muncul duplikasi, sementara kita catat dulu.

private static IExpression createPuluhan(string ekspresi)
{
	char[] exs=ekspresi.ToCharArray();
	IExpression puluhan=Number.CreateNewNumber(exs[0].ToString());
	IExpression satuan=Number.CreateNewNumber(exs[1].ToString());
	return new Puluhan(puluhan,satuan);
}

Test saya jalankan. Satu test break: FactoryNumberException. Ini muncul karena method CreateNewNumber yang tadinya tidak bisa menerima puluhan sekarang bisa. Sehingga agar green kembali, eksepsinya saya ganti menjadi ratusan.

[Test]
[ExpectedException(typeof(ApplicationException),"Expression 200 not supported")]
public void FactoryNumberException()
{
	Number.CreateNewNumber("200");
}

Test saya jalankan. Semuanya green.

Berikutnya kita ubah sedikit method Convert. Perhatikan code berikut ini,

public IExpression Convert (string ekspresi)
{
	if(ekspresi.Length==1)
		return Number.CreateNewNumber(ekspresi);
	else if (ekspresi.Length == 2)
	{
		char[] exs=ekspresi.ToCharArray();
		IExpression puluhan=Number.CreateNewNumber(exs[0].ToString());
		IExpression satuan=Number.CreateNewNumber(exs[1].ToString());
		return new Puluhan(puluhan,satuan);
	}
	else if(ekspresi.Length>2)
	    return interpret(ekspresi);
	else
		throw new ApplicationException(string.Format("Expression {0} not supported",ekspresi));
}

Bandingkan dengan method createPuluhan sebelumnya, sama bukan? Karena itu bagian kedua dari method ini bisa kita gantikan dengan Number.CreateNewNumber,

public IExpression Convert (string ekspresi)
{
	if(ekspresi.Length==1)
		return Number.CreateNewNumber(ekspresi);
	else if (ekspresi.Length == 2)
	{
		return Number.CreateNewNumber(ekspresi);
	}
	else if(ekspresi.Length>2)
	    return interpret(ekspresi);
	else
		throw new ApplicationException(string.Format("Expression {0} not supported",ekspresi));
}

Sehingga bagian 1 dan bagian 2 sama persis.

Test saya jalankan. Tidak ada yang berubah. Tadinya saya ingin merefactor bagian 1 dan 2 menjadi satu bagian saja, tapi saya melihat ada kemungkinan untuk melenyapkan semuanya menjadi interpret saja. Sebab, bagian eksepsi itu sudah tidak ada gunanya karena jika lebih besar dari 2 semua akan lari kebagian 3 dan tidak akan pernah sampai ke bagian 4.

Ekspresi Penjumlahan

Ekspresi penjumlahan adalah “+”. Ekspresi ini merupakan komposisi dua ekspresi, satu sebagai tambahan dan yang satu sebagai yang ditambah, yang bisa kita nyatakan sebagai:”x + y”.

Sebelum kita membuat konversi ekspresi penjumlahan, kita harus membuat komposisi penjumlahan. Komposisi ini saya sebut sebagai komposisi Plus.

Berikut ini adalah test untuk komposisi Plus,

[Test]
public void KomposisiPlus()
{
	IExpression puluhan=Number.CreateNewNumber("2");
	IExpression satuan=Number.CreateNewNumber("0");
	IExpression asal=new Puluhan(puluhan,satuan);
	IExpression tambahan=Number.CreateNewNumber("0");
	IExpression plus=new Plus(asal, tambahan);
	Assert.AreEqual("20 + 0",plus.Expression);
	Assert.AreEqual(20,plus.Value);
}

Komposisi ini terbuat dari 20 dan 0 yang masing-masing dinyatakan dengan komposisi Puluhan dan Number 0. Komposisi puluhan terbuat dari Numer 2 dan Number 0. Kesemuanya adalah ekspresi.

Agar test bisa berjalan kita harus membuat class Plus,

public class Plus:IExpression
{
	private IExpression m_asal;
	private IExpression m_tambahan;
	public Plus(IExpression asal, IExpression tambahan)
	{
		this.m_asal= asal;
		this.m_tambahan = tambahan;
	}
	public string Expression {
		get {
			return "";
		}
	}
	public object Value {
		get {
			return 0;
		}
	}
}

Konstruktor dari class Plus berparameter dua buah ekspresi number, yang satu sebagai nilai awal dan yang kedua sebagai nilai tambah. Test diatas masih memberi keluaran red. Namun demikian implementasi keduanya adalah sangat jelas. Untuk property Expression kita cukup menggabungkan ekspresi pembentuknya dan untuk Value kita juga cukup menjumlahkan kedua value dari ekspresi pembentuknya.

public class Plus:IExpression
{ 

	public string Expression {
		get {
			return String.Format("{0} + {1}",this.m_asal.Expression,this.m_tambahan.Expression);
		}
	}
	public object Value {
		get {
			return (int)this.m_asal.Value + (int)this.m_tambahan.Value;
		}
	}
}

Implementasi sederhana yang cukup membuat test kita menjadi green.

Sekarang kita buat konversi ekspresi plus. Berikut ini adalah test konversi “1 + 1” ke object Plus.

[Test]
public void Ekspresiplus(){
	string input="1 + 1";
	IExpressionConverter exConverter=new ExpressionConverter();
	IExpression ex=exConverter.Convert(input);
	Assert.AreEqual("1 + 1",ex.Expression);
	Assert.AreEqual(2,ex.Value);
}

Jika test kita jalankan, kita akan menetapkan pesan bahwa ekspresi “1 + 1” tidak disupport. Jadi, apa yang akan kita lakukan? Tidak ada implementasi yang jelas yang langsung bisa kita implementasikan.

Saya punya usul. Ekspresi ini kita pecah-pecah menurut komponennya, ada 3 komponen. Ekspresi 1, komposisi Plus dan ekspresi 1. Ekspresi 1 + 1, kita masukkan dulu kedalam array, kemudian kita baca baris demi baris, jika ketemu 1 buat ekspresi 1 dan jika ketemu + buat ekspresi plus.

Kita berikan implementasi konstant dulu,

public IExpression Convert (string ekspresi)
{
	if(ekspresi.Length==1)
		return Number.CreateNewNumber(ekspresi);
	else if (ekspresi.Length == 2)
	{
		char[] exs=ekspresi.ToCharArray();
		IExpression puluhan=Number.CreateNewNumber(exs[0].ToString());
		IExpression satuan=Number.CreateNewNumber(exs[1].ToString());
		return new Puluhan(puluhan,satuan);
	}
	else if(ekspresi.Equals("1 + 1"))
	    return Number.CreateNewNumber("1") ;
	else
		throw new ApplicationException(string.Format("Expression {0} not supported",ekspresi));
}

Perhatikan statement “else if(ekspresi.Equals(“1 + 1″)) ”, saya berikan implementasi konstan disini. Dan ini langsung menimbulkan duplikasi data, didalam test dan didalam program.

Agar test ini menjadi green, cara termudah adalah dengan memberikan impelemantasi Plus,

public IExpression Convert (string ekspresi)
{
	if(ekspresi.Length==1)
		return Number.CreateNewNumber(ekspresi);
	else if (ekspresi.Length == 2)
	{
		char[] exs=ekspresi.ToCharArray();
		IExpression puluhan=Number.CreateNewNumber(exs[0].ToString());
		IExpression satuan=Number.CreateNewNumber(exs[1].ToString());
		return new Puluhan(puluhan,satuan);
	}
	else if(ekspresi.Equals("1 + 1"))
	    return new Plus(Number.CreateNewNumber("1"),Number.CreateNewNumber("1"));
	else
		throw new ApplicationException(string.Format("Expression {0} not supported",ekspresi));
}

Test kita sudah green. Langkah berikutnya kita harus bisa menghilangkan duplikasi. Kita pindahkan terlebih daulu new Plus() ke dalam method baru katakanlah method interpret.

	else if(ekspresi.Equals("1 + 1"))
			    return interpret(ekspresi);

dan method interprete,

private IExpression interpret(string ekspresi)
{
	return new Plus(Number.CreateNewNumber("1"),Number.CreateNewNumber("1"));
}

kita tidak akan membatasi seberapa panjang ekspresi yang masuk, maka kita ubah jika panjang ekspresi lebih dari 2 eksekusi interpret,

public IExpression Convert (string ekspresi)
{
	if(ekspresi.Length==1)
		return Number.CreateNewNumber(ekspresi);
	else if (ekspresi.Length == 2)
	{
		char[] exs=ekspresi.ToCharArray();
		IExpression puluhan=Number.CreateNewNumber(exs[0].ToString());
		IExpression satuan=Number.CreateNewNumber(exs[1].ToString());
		return new Puluhan(puluhan,satuan);
	}
	else if(ekspresi.Length>2)
	    return interpret(ekspresi);
	else
		throw new ApplicationException(string.Format("Expression {0} not supported",ekspresi));
}

Test tetap green.

Sekarang kita siap mengoprek interpret. Seperti ide kita semula, kita buat ekspresi masing-masing,

private IExpression interpret(string ekspresi)
{
	IExpression exp1=getExp1(ekspresi);
	IExpression exp2=getExp2(ekspresi);
	return getOperator(ekspresi,exp1,exp2);
}

Method getExp1 ditujukan untuk mengambil ekpresi pertama dari penjumlahan. Kemudian getExp2 ditujukan untuk menngambil ekspresi kedua penyusun penjumlahan. Sedangkan getOperator, diguanakan untuk mendapatkan operator apa, kebetulan saat ini penjumlahan.

Method getExp1,

private IExpression getExp1(string exs)
{
	string[] splitedStr=exs.Split('+');
	string number= splitedStr[0].Trim();
	return Number.CreateNewNumber(number);
}

Pertama-tama string ekspresi kita split berdasarkan karakter +, sementara kita abaikan kemungkinan operator lain. Hasil dari split ini adalah array string, str[0] =”1” dan str[2]=”1”. Dengan demikian ekspresi pertama adalah str[0]. Untuk menghilangkan white space kita panggil trim. Kemudian kita panggil Number.

Method getExp2,

private IExpression getExp2(string exs)
{
	string[] splitedStr=exs.Split('+');
	string number= splitedStr[1].Trim();
	return Number.CreateNewNumber(number);
}

Tidak berbeda dari getExp1, kecuali pada saat mengambil array. Disini kita ambil array yang ke dua. Ini kandidat untuk bisa kita satukan.

Dan getOperator,

private IExpression getOperator(string ekspresi,IExpression exp1, IExpression exp2)
{
	string afterExp1=ekspresi.Substring(exp1.Expression.Length).Trim();
	string opr=afterExp1.Substring(0,1);
	if(opr.Equals("+")){
		return new Plus(exp1,exp2);
	}else
		throw new ApplicationException(String.Format("Expression {0} not operator",opr));
}

Logikanya adalah kita ambil substring yang dimulai dari karakter setelah ekspresi pertama. Jadi untuk 1 + 1, substringnya adalah + 1. Setelah itu kita ambil karakter pertama dari substring. Kemudian kita uji karakter itu + atau bukan. Jika plus buat ekspresi plus, jika bukan keluarkan eksepsi.

Dengan cara ini test sudah green. Karena getExp1 dan getExp2 modelnya sama kita bisa satukan, yaitu dengan memanggil getExp. Sufix 1 dan 2 kita pertahankan. Penting sebagai tanda bahwa komposisi kita kesemuanya membutuhkan ekspresi 1 dan ekspresi 2.

private IExpression getExp(int oprNumber,string exs)
{
	string[] splitedStr=exs.Split('+');
	if(splitedStr.Length <=oprNumber)
		return Number.CreateNewNumber("0");
	string number= splitedStr[oprNumber].Trim();
	return Number.CreateNewNumber(number);
}

Jika operator number yang kita inginkan ternyata lebih besar dari array yang ada kita return number ‘0′.

Dan getExp1 dan getExp2 berubah menjadi,

private IExpression getExp1(string exs)
{
	return getExp(0,exs);
}
private IExpression getExp2(string exs)
{
	return getExp(1,exs);
}