From 809ad93141dd9cb7122cc2f549b0f8950f2ce439 Mon Sep 17 00:00:00 2001
From: brettlangdon <brett@blangdon.com>
Date: Sun, 21 Jun 2015 18:50:43 -0400
Subject: [PATCH] add start to primative tests

---
 primative_test.go | 262 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 262 insertions(+)
 create mode 100644 primative_test.go

diff --git a/primative_test.go b/primative_test.go
new file mode 100644
index 0000000..3a0b112
--- /dev/null
+++ b/primative_test.go
@@ -0,0 +1,262 @@
+package forge_test
+
+import (
+	"testing"
+
+	"github.com/brettlangdon/forge"
+)
+
+func TestNewPrimative(t *testing.T) {
+	t.Parallel()
+
+	value, err := forge.NewPrimative(true)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	if value.GetType() != forge.BOOLEAN {
+		t.Error("value is not a BOOLEAN")
+		return
+	}
+
+	rawVal := value.GetValue()
+	switch rawVal.(type) {
+	case bool:
+		// this is what we want to happen
+	default:
+		t.Error("expected value.GetValue() to be a bool")
+		return
+	}
+
+	if rawVal.(bool) != true {
+		t.Error("expected value.GetValue() to be equal to 'true'")
+	}
+}
+
+func TestNewBoolean(t *testing.T) {
+	t.Parallel()
+
+	value := forge.NewBoolean(true)
+
+	if value.GetType() != forge.BOOLEAN {
+		t.Error("value is not a BOOLEAN")
+		return
+	}
+
+	rawVal := value.GetValue()
+	switch rawVal.(type) {
+	case bool:
+		// this is what we want to happen
+	default:
+		t.Error("expected value.GetValue() to be a bool")
+		return
+	}
+
+	if rawVal.(bool) != true {
+		t.Error("expected value.GetValue() to be equal to 'true'")
+	}
+}
+
+func TestNewFloat(t *testing.T) {
+	t.Parallel()
+
+	value := forge.NewFloat(50.5)
+
+	if value.GetType() != forge.FLOAT {
+		t.Error("value is not a FLOAT")
+		return
+	}
+
+	rawVal := value.GetValue()
+	switch rawVal.(type) {
+	case float64:
+		// this is what we want to happen
+	default:
+		t.Error("expected value.GetValue() to be a float64")
+		return
+	}
+
+	if rawVal.(float64) != 50.5 {
+		t.Error("expected value.GetValue() to be equal to '50.5'")
+	}
+}
+
+func TestNewInteger(t *testing.T) {
+	t.Parallel()
+
+	value := forge.NewInteger(50)
+
+	if value.GetType() != forge.INTEGER {
+		t.Error("value is not a INTEGER")
+		return
+	}
+
+	rawVal := value.GetValue()
+	switch rawVal.(type) {
+	case int64:
+		// this is what we want to happen
+	default:
+		t.Error("expected value.GetValue() to be a int64")
+		return
+	}
+
+	if rawVal.(int64) != 50 {
+		t.Error("expected value.GetValue() to be equal to '50'")
+	}
+}
+
+func TestNewNull(t *testing.T) {
+	t.Parallel()
+
+	value := forge.NewNull()
+
+	if value.GetType() != forge.NULL {
+		t.Error("value is not a NULL")
+		return
+	}
+
+	rawVal := value.GetValue()
+	switch rawVal.(type) {
+	case nil:
+		// this is what we want to happen
+	default:
+		t.Error("expected value.GetValue() to be a nil")
+		return
+	}
+
+	if rawVal != nil {
+		t.Error("expected value.GetValue() to be equal to 'nil'")
+	}
+}
+
+func TestNewString(t *testing.T) {
+	t.Parallel()
+
+	value := forge.NewString("hello")
+
+	if value.GetType() != forge.STRING {
+		t.Error("value is not a STRING")
+		return
+	}
+
+	rawVal := value.GetValue()
+	switch rawVal.(type) {
+	case string:
+		// this is what we want to happen
+	default:
+		t.Error("expected value.GetValue() to be a string")
+		return
+	}
+
+	if rawVal.(string) != "hello" {
+		t.Error("expected value.GetValue() to be equal to '\"hello\"'")
+	}
+}
+
+func TestUpdateValue(t *testing.T) {
+	t.Parallel()
+
+	value := forge.NewNull()
+
+	// Boolean
+	err := value.UpdateValue(true)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if value.GetType() != forge.BOOLEAN {
+		t.Error("value is not a BOOLEAN")
+		return
+	}
+	if value.GetValue().(bool) != true {
+		t.Error("expected value.GetValue() to be equal to 'true'")
+	}
+
+	// Float
+	err = value.UpdateValue(50.5)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if value.GetType() != forge.FLOAT {
+		t.Error("value is not a FLOAT")
+		return
+	}
+	if value.GetValue().(float64) != 50.5 {
+		t.Error("expected value.GetValue() to be equal to '50.5'")
+	}
+
+	// Integer int
+	err = value.UpdateValue(50)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if value.GetType() != forge.INTEGER {
+		t.Error("value is not a INTEGER")
+		return
+	}
+	if value.GetValue().(int64) != 50 {
+		t.Error("expected value.GetValue() to be equal to '50'")
+	}
+
+	// Integer int64
+	err = value.UpdateValue(int64(50))
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if value.GetType() != forge.INTEGER {
+		t.Error("value is not a INTEGER")
+		return
+	}
+	if value.GetValue().(int64) != 50 {
+		t.Error("expected value.GetValue() to be equal to '50'")
+	}
+
+	// Null
+	err = value.UpdateValue(nil)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if value.GetType() != forge.NULL {
+		t.Error("value is not a NULL")
+		return
+	}
+	if value.GetValue() != nil {
+		t.Error("expected value.GetValue() to be equal to '50'")
+	}
+
+	// String
+	err = value.UpdateValue("hello")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if value.GetType() != forge.STRING {
+		t.Error("value is not a STRING")
+		return
+	}
+	if value.GetValue().(string) != "hello" {
+		t.Error("expected value.GetValue() to be equal to '\"hello\"'")
+		return
+	}
+
+}
+
+func TestUpdateValueUnknown(t *testing.T) {
+	value, err := forge.NewPrimative("hello")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	newVal := []string{"hello", "world"}
+	err = value.UpdateValue(newVal)
+	if err == nil {
+		t.Error("expected an error, got none")
+		return
+	}
+}