IT 기술 따라잡기

!|CombinationFixtureTest|
|  |1 |2|3|
|6 |6 |3|2|
|12|12|6|4|

package info.fitnesse.fixturegallery;

import fitlibrary.CombinationFixture;

public class CombinationFixtureTest extends CombinationFixture{
    public int combine(int theFirst, int theSecond) {
        return theFirst / theSecond;
    }
}

using fitlibrary;

namespace info.fitnesse.fixturegallery {
    public class CombinationFixtureTest: CombinationFixture {
        public int combine(int theFirst, int theSecond) {
            return theFirst / theSecond;
        }
    }
}

# PYTHON: info.fitnesse.fixturegallery.CombinationFixtureTest
from fitLib.CombinationFixture import CombinationFixture

class CombinationFixtureTest(CombinationFixture):
    _typeDict = {}

    # PY3K: combine(theFirst : int, theSecond : int) : int
    _typeDict["combine.types"] = [ "Int", "Int", "Int" ]
    def combine(self, theFirst, theSecond):
        return theFirst / theSecond

!include -seamless SetUpFixture

!|ArrayFixtureTest|
|name|post code|credit limit|
|John Smith|SW4 66Z|10|
|Michael Jordan|NE1 8AT|12|

package info.fitnesse.fixturegallery;
import info.fitnesse.fixturegallery.domain.Player;
import fitlibrary.ArrayFixture;

public class ArrayFixtureTest extends ArrayFixture{
    public ArrayFixtureTest() {
        setActualCollection(Player.players);
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace info.fitnesse.fixturegallery
{
    public class ArrayFixtureTest: fitlibrary.ArrayFixture
    {
        public ArrayFixtureTest():base(Player.players)
        {
        }
    }
}

from fitLib.ArrayFixture import ArrayFixture
from info.fitnesse.fixturegallery.domain.Player import Player

class ArrayFixtureTest(ArrayFixture):
    def __init__(self):
        ArrayFixture.__init__(self)
        self.paramCollection = Player.players
        self.setActualCollection()

    def getTargetClass(self):
        return Player   #< TYPE-HINT: For ValueObject class.

!|SequenceFixtureTest|
|fill|10|x|
|check|char at|4|x|
|set list|A,B,C,D|
|check|char at|2|C|

package info.fitnesse.fixturegallery;
import java.util.Arrays;
import fitlibrary.SequenceFixture;

public class SequenceFixtureTest extends SequenceFixture{
    public String letters;
    public void fill(int count,char c){
        char[] arr=new char[count];
        Arrays.fill(arr,c);
        letters=new String(arr);
    }
    public void setList(char[] array){
        letters=new String(array);
    }
    public char charAt(int position){
        return letters.charAt(position);
    }
}

using System;

namespace info.fitnesse.fixturegallery
{
    public class SequenceFixtureTest : fitlibrary.SequenceFixture
    {
        private String contents;
        public void Fill(int howmany, String what)
        {
            contents = "";
            for (int i = 0; i < howmany; i++)
            {
                contents = contents + what;
            }
        }
        public void SetList(String[] strings)
        {
            contents = "";
            foreach (String s in strings)
            {
                contents = contents + s;
            }
        }
        public char CharAt(int index)
        {
            return contents[index];
        }
    }
}

from fitLib.SequenceFixture import SequenceFixture
from info.fitnesse.fixturegallery.typeadapter import buildListTypeAdapterFor

class SequenceFixtureTest(SequenceFixture):
    _typeDict = {}

    def __init__(self):
        self.letters = ""

    _typeDict["fill.types"] = [ None, "Integer", "Char" ]
    def fill(self, count, c):
        self.letters = c * count    #< FILL: Repeact char count times.

    # JAVA: public void setList(char[] array){
    ARRAY_OF_CHAR_TYPE_ADAPTER = buildListTypeAdapterFor("Char")
    _typeDict["setList.types"] = [ None, ARRAY_OF_CHAR_TYPE_ADAPTER ]
    def setList(self, array):
        self.letters = "".join(array)   #< Concatenate array of chars to string.

    _typeDict["charAt.types"] = [ "Char", "Integer" ]
    def charAt(self, position):
        return self.letters[position]

Usage

SequenceFixture는 DoFixture 가 가지고 있는 모든 flexibility와 기능을 모두 가지고 있습니다. 오직 method naming만 다릅니다. 이 fixture는 좀 더 technical 한 workflow test에 유용합니다.

!|DoFixtureTest|
|fill|10|times with|x|
|char at|4|is|x|
|set list|A,B,C,D|
|char at|2|is|C|

package info.fitnesse.fixturegallery;
import java.util.Arrays;
import fitlibrary.DoFixture;

public class DoFixtureTest extends DoFixture {
	public String letters;
	public void fillTimesWith(int count,char c){
		char[] arr=new char[count];
		Arrays.fill(arr,c);
		letters=new String(arr);
	}
	public boolean charAtIs(int position, char c){
		return letters.charAt(position)==c;
	}
	public void setList(char[] array){
		letters=new String(array);
	}
	public char charAt(int position){
		return letters.charAt(position);
	}
}

using System;
using System.Collections.Generic;
using System.Text;

namespace info.fitnesse.fixturegallery
{
    public class DoFixtureTest : fitlibrary.DoFixture
    {
        private String contents;
        public void FillTimesWith(int howmany, String what)
        {
            contents = "";
            for (int i = 0; i < howmany; i++)
            {
                contents = contents + what;
            }
        }
        public bool CharAtIs(int index, char c)
        {
            return contents[index]==c;
        }
        public void SetList(String[] strings)
        {
            contents = "";
            foreach (String s in strings)
            {
                contents = contents + s;
            }
        }
        //
        public char CharAt(int index)
        {
            return contents[index];
        }
    }
}

# NOTES:
#   This Fixture is not sensible in Python.
#   Python does not worry about character arrays, strings are used instead.
#   Therefore, a TypeAdapter for char is not supported by PyFIT.
#   I supplied one in this package

from fitLib.DoFixture import DoFixture
from info.fitnesse.fixturegallery.typeadapter import buildListTypeAdapterFor

class DoFixtureTest(DoFixture):
    _typeDict = {
        "letters": "String"
    }

    def __init__(self):
        DoFixture.__init__(self)
        self.letters = ""

    # JAVA: void fillTimesWith(int count,char c){
    _typeDict["fillTimesWith.types"] = [None, "Integer", "Char" ]
    def fillTimesWith(self, count, c):
        self.letters = c * count    #< FILL: Repeat char ``count`` times.

    # JAVA: boolean charAtIs(int position, char c){
    _typeDict["charAtIs.types"] = ["Boolean", "Integer", "Char" ]
    def charAtIs(self, position, c):
        return self.letters[position] == c

    # JAVA: void setList(char[] array){
    ARRAY_OF_CHAR_TYPE_ADAPTER = buildListTypeAdapterFor("Char")
    _typeDict["setList.types"] = [ None, ARRAY_OF_CHAR_TYPE_ADAPTER ]
    def setList(self, array):
        self.letters = "".join(array)

    # JAVA: char charAt(int position){
    _typeDict["charAt.types"] = [ "Char", "Integer" ]
    def charAt(self, position):
        return self.letters[position]

!|DoFixtureTest|
|fill|10|times with|x|
|check|char at|4|x|
|set list|A,B,C,D|
|show|char at|2|

!|CalculateFixtureTest|
|firstPart|secondPart||together|
|Hello|World||Hello, World|
|Houston|We Have a Problem||Houston, We Have a Problem|

package info.fitnesse.fixturegallery;

import fitlibrary.CalculateFixture;

public class CalculateFixtureTest extends CalculateFixture{
	public String togetherFirstPartSecondPart(String firstPart,String secondPart){
		return firstPart+ ", "+secondPart;
	}
}

using fitlibrary;
using System;

namespace info.fitnesse.fixturegallery
{
	public class CalculateFixtureTest: CalculateFixture
	{
		public String TogetherFirstPartSecondPart(String firstPart,String secondPart)
		{
			return firstPart+ ", "+secondPart;
		}
	}
}

from fitLib.CalculateFixture import CalculateFixture

class CalculateFixtureTest(CalculateFixture):
    _typeDict = {}

    # JAVA: String togetherFirstPartSecondPart(String firstPart,String secondPart){
    _typeDict["togetherFirstPartSecondPart.types"] = ["String", "String", "String"]
    def togetherFirstPartSecondPart(self, firstPart, secondPart):
        return "%s, %s" % (firstPart, secondPart)

!|SetUpFixtureTest|
|player|post code|balance|
|John Smith|SW4 66Z|10.00|
|Michael Jordan|NE1 8AT|12.00|

package info.fitnesse.fixturegallery;

import info.fitnesse.fixturegallery.domain.Player;

import java.util.ArrayList;
import java.util.List;

import fitlibrary.SetUpFixture;

public class SetUpFixtureTest extends SetUpFixture{
	public SetUpFixtureTest() {
		 Player.players.clear();
	}
	public void playerPostCodeBalance(String name, String postCode, double balance){
	 Player.addPlayer(name, postCode, balance) ;
 }
}

namespace info.fitnesse.fixturegallery
{
    public class SetUpFixtureTest : fitlibrary.SetUpFixture
    {
        public SetUpFixtureTest()
        {
            Player.players.Clear();
        }
        public void PlayerPostcodeBalance(string player, string postCode, decimal balance)
        {
            Player p = new Player();
            p.Name = player;
            p.PostCode = postCode;
            p.Balance = balance;
            Player.players.Add(p);
        }
       }
}

from fitLib.SetUpFixture import SetUpFixture
from info.fitnesse.fixturegallery.domain.Player import Player

class SetUpFixtureTest(SetUpFixture):
    _typeDict = {}

    def __init__(self):
        Player.players = []

    # JAVA: void playerPostCodeBalance(String name, String postCode, double balance){
    _typeDict["playerPostCodeBalance.types"] = [ None, "String", "String", "Float" ]
    def playerPostCodeBalance(self, name, postCode, balance):
        Player.addPlayer(name, postCode, balance)

|Import|
|info.fitnesse.fixturegallery|

package info.fitnesse.fixturegallery;

import info.fitnesse.fixturegallery.domain.TaxCalculator;
import fitnesse.fixtures.TableFixture;

public class TableFixtureTest extends TableFixture{
	protected void doStaticTable(int rows) {
		 TaxCalculator tc=new TaxCalculator();
	      double totaltax = 0;

	      for (int row = 1; row < rows - 3; row++)
	      {
	        totaltax += tc.GetTax(getText(row, 1),
	          Double.parseDouble(getText(row, 2)));
	      }
	      double taxintable = Double.parseDouble(getText(rows - 2, 2));
	      if (taxintable == totaltax)
	        right(rows - 2, 2);
	      else
	        wrong(rows - 2, 2,String.valueOf(totaltax));
	    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace info.fitnesse.fixturegallery
{
    public class TableFixtureTest : global::fitnesse.fixtures.TableFixture
    {
        protected override void DoStaticTable(int rows)
        {
            TaxCalculator tc = new TaxCalculator();
            decimal totaltax = 0;
            for (int row = 1; row < rows - 3; row++)
            {
                totaltax += tc.GetTax(GetString(row, 1),
                  Decimal.Parse(GetString(row, 2)));
            }
            decimal taxintable = Decimal.Parse(GetString(rows - 2, 2));
            if (taxintable == totaltax)
                Right(rows - 2, 2);
            else
                Wrong(rows - 2, 2, totaltax.ToString());
        }
    }

}

from info.fitnesse.fixturegallery.domain.TaxCalculator import TaxCalculator
from fitnesse.fixtures.TableFixture import TableFixture

class TableFixtureTest(TableFixture):
    def doStaticTable(self, rows):
        tc = TaxCalculator()
        totalTax = 0.0

        for row in range(1, rows - 3):
            totalTax += tc.getTax(self.getText(row, 1),
                                  float(self.getText(row, 2)))

        taxinTable = float(self.getText(rows - 2, 2))
        if taxinTable == totalTax:
            self.right(self.getCell(rows - 2, 2))
        else:
            self.wrong(self.getCell(rows - 2, 2), str(totalTax))

package info.fitnesse.fixturegallery;

import info.fitnesse.fixturegallery.domain.Player;
import fit.RowFixture;

public class RowFixtureTest extends RowFixture{
	public Class getTargetClass() {
		return Player.class;
	}
	public Object[] query() throws Exception {
			return Player.players.toArray();
	}
}

using System;
using System.Collections.Generic;
using System.Text;

namespace info.fitnesse.fixturegallery
{
    public class RowFixtureTest: fit.RowFixture
    {
        public override Type GetTargetClass()
        {
            return typeof(Player);
        }
        public override object[] Query()
        {
            return Player.players.ToArray();
        }
    }
}

from fit.RowFixture import RowFixture
from info.fitnesse.fixturegallery.domain.Player import Player

class RowFixtureTest(RowFixture):
    def getTargetClass(self):
        return Player

    def query(self):
        return list(Player.players) #< Return copy of players