added element type with tests (d92f1646) · Commits · bsmrgo / elemental

element.go

0 → 100644

+121 −0

Original line number	Diff line number	Diff line
		package elemental

		type Element uint

		const (
		UnspecifiedElement Element = iota
		WoodElement
		FireElement
		EarthElement
		MetalElement
		WaterElement
		)

		const (
		textUnspecifiedElement = "unspecified"
		textWoodElement = "wood"
		textFireElement = "fire"
		textEarthElement = "earth"
		textMetalElement = "metal"
		textWaterElement = "water"
		)

		// String returns the string representation of an element.
		func (e Element) String() string {
		switch e {
		case WoodElement:
		return textWoodElement
		case FireElement:
		return textFireElement
		case EarthElement:
		return textEarthElement
		case MetalElement:
		return textMetalElement
		case WaterElement:
		return textWaterElement
		default:
		return textUnspecifiedElement
		}
		}

		// GeneratingInteraction returns the "gerating interaction" of the current element.
		func (e Element) GeneratingInteraction() Element {
		switch e {
		case WoodElement:
		return FireElement
		case FireElement:
		return EarthElement
		case EarthElement:
		return MetalElement
		case MetalElement:
		return WaterElement
		case WaterElement:
		return WoodElement
		default:
		return UnspecifiedElement
		}
		}

		// OvercomingInteraction returns the "overcoming interaction" of the current element.
		func (e Element) OvercomingInteraction() Element {
		switch e {
		case WoodElement:
		return EarthElement
		case FireElement:
		return MetalElement
		case EarthElement:
		return WaterElement
		case MetalElement:
		return WoodElement
		case WaterElement:
		return FireElement
		default:
		return UnspecifiedElement
		}
		}

		// Friendly returns the neighbouring elements of the current element.
		func (e Element) Friendly() []Element {
		switch e {
		case WoodElement:
		return []Element{WaterElement, FireElement}
		case FireElement:
		return []Element{WoodElement, EarthElement}
		case EarthElement:
		return []Element{FireElement, MetalElement}
		case MetalElement:
		return []Element{EarthElement, WaterElement}
		case WaterElement:
		return []Element{MetalElement, WoodElement}
		default:
		return []Element{UnspecifiedElement}
		}
		}

		// Opposing returns the opposing elements of the current element.
		func (e Element) Opposing() []Element {
		switch e {
		case WoodElement:
		return []Element{EarthElement, MetalElement}
		case FireElement:
		return []Element{MetalElement, WaterElement}
		case EarthElement:
		return []Element{WaterElement, WoodElement}
		case MetalElement:
		return []Element{WoodElement, FireElement}
		case WaterElement:
		return []Element{FireElement, EarthElement}
		default:
		return []Element{UnspecifiedElement}
		}
		}

		// ContainedIn checks if the current element belongs to a slice of elements.
		func (e Element) ContainedIn(elements []Element) bool {
		for _, element := range elements {
		if e == element {
		return true
		}
		}
		return false
		}

element_test.go

0 → 100644

+95 −0

Original line number	Diff line number	Diff line
		package elemental

		import "testing"

		func TestElementString(t *testing.T) {
		for _, v := range []struct {
		e Element
		s string
		}{
		{e: UnspecifiedElement, s: textUnspecifiedElement},
		{e: WoodElement, s: textWoodElement},
		{e: FireElement, s: textFireElement},
		{e: EarthElement, s: textEarthElement},
		{e: MetalElement, s: textMetalElement},
		{e: WaterElement, s: textWaterElement},
		} {
		if es := v.e.String(); es != v.s {
		t.Errorf("String() returned %q, expected %q", es, v.s)
		}
		}
		}

		func TestGeneratingInteraction(t *testing.T) {
		for _, v := range []struct {
		e Element
		g Element
		}{
		{e: WoodElement, g: FireElement},
		{e: FireElement, g: EarthElement},
		{e: EarthElement, g: MetalElement},
		{e: MetalElement, g: WaterElement},
		{e: WaterElement, g: WoodElement},
		{e: UnspecifiedElement, g: UnspecifiedElement},
		} {
		if eg := v.e.GeneratingInteraction(); eg != v.g {
		t.Errorf("%q.GeneratingInteraction() is %q, expected %q", v.e, eg, v.g)
		}
		}
		}

		func TestOvercomingInteraction(t *testing.T) {
		for _, v := range []struct {
		e Element
		g Element
		}{
		{e: WoodElement, g: EarthElement},
		{e: FireElement, g: MetalElement},
		{e: EarthElement, g: WaterElement},
		{e: MetalElement, g: WoodElement},
		{e: WaterElement, g: FireElement},
		{e: UnspecifiedElement, g: UnspecifiedElement},
		} {
		if eg := v.e.OvercomingInteraction(); eg != v.g {
		t.Errorf("%q.OvercomingInteraction() is %q, expected %q", v.e, eg, v.g)
		}
		}
		}

		func TestFriendly(t *testing.T) {
		for _, v := range []struct {
		e Element
		a []Element
		}{
		{e: WoodElement, a: []Element{WaterElement, FireElement}},
		{e: FireElement, a: []Element{WoodElement, EarthElement}},
		{e: EarthElement, a: []Element{FireElement, MetalElement}},
		{e: MetalElement, a: []Element{EarthElement, WaterElement}},
		{e: WaterElement, a: []Element{MetalElement, WoodElement}},
		{e: UnspecifiedElement, a: []Element{UnspecifiedElement}},
		} {
		r := v.e.Friendly()
		if !v.e.ContainedIn(v.a) {
		t.Errorf("%q.Friendly() returned %#v, expected %#v", v.e, r, v.a)
		}
		}
		}

		func TestOpposing(t *testing.T) {
		for _, v := range []struct {
		e Element
		a []Element
		}{
		{e: WoodElement, a: []Element{EarthElement, MetalElement}},
		{e: FireElement, a: []Element{MetalElement, WaterElement}},
		{e: EarthElement, a: []Element{WaterElement, WoodElement}},
		{e: MetalElement, a: []Element{WoodElement, FireElement}},
		{e: WaterElement, a: []Element{FireElement, EarthElement}},
		{e: UnspecifiedElement, a: []Element{UnspecifiedElement}},
		} {
		r := v.e.Opposing()
		if !v.e.ContainedIn(v.a) {
		t.Errorf("%q.Opposing() returned %#v, expected %#v", v.e, r, v.a)
		}
		}
		}