func Test_CLG_Round(t *testing.T) {
testCases := []struct {
Float float64
Precision int
Expected float64
}{
{
Float: 3.5,
Precision: 0,
Expected: 4,
},
{
Float: 3.4,
Precision: 0,
Expected: 3,
},
{
Float: 3.4,
Precision: 1,
Expected: 3.4,
},
{
Float: 3.4,
Precision: 2,
Expected: 3.4,
},
{
Float: 3.476,
Precision: 2,
Expected: 3.48,
},
{
Float: -3.476,
Precision: 2,
Expected: -3.48,
},
{
Float: 3,
Precision: 0,
Expected: 3,
},
{
Float: 3,
Precision: 2,
Expected: 3,
},
}
newCLG := MustNew()
for i, testCase := range testCases {
f, err := newCLG.(*clg).calculate(context.MustNew(), testCase.Float, testCase.Precision)
if err != nil {
t.Fatal("case", i+1, "expected", nil, "got", err)
}
if f != testCase.Expected {
t.Fatal("case", i+1, "expected", testCase.Expected, "got", f)
}
}
}
func Test_CLG_Input_UnknownInputSequence(t *testing.T) {
newCLG := MustNew()
newCtx := context.MustNew()
newServiceCollection := testMustNewServiceCollection(t)
newStorageCollection := testMustNewStorageCollection(t)
// Note we do not create a record for the test input. This test is about an
// unknown input sequence.
newInput := "test input"
// Set prepared storage to CLG we want to test.
newCLG.(*clg).ServiceCollection = newServiceCollection
newCLG.(*clg).StorageCollection = newStorageCollection
// Execute CLG.
err := newCLG.(*clg).calculate(newCtx, newInput)
if err != nil {
t.Fatal("expected", nil, "got", err)
}
// Check if the information ID was set to the context.
injectedInformationID, _ := newCtx.GetInformationID()
if injectedInformationID != "new-ID" {
t.Fatal("expected", true, "got", false)
}
}
func Test_CLG_Round_Error_NegativePrecision(t *testing.T) {
newCLG := MustNew()
_, err := newCLG.(*clg).calculate(context.MustNew(), 3.4465, -3)
if !IsParseFloatSyntax(err) {
t.Fatal("case", "expected", true, "got", false)
}
}
func Test_CLG_Input_SetInformationSequenceError(t *testing.T) {
newCLG := MustNew()
newCtx := context.MustNew()
newServiceCollection := testMustNewServiceCollection(t)
// Prepare the storage connection to fake a returned error.
newInput := "test input"
informationIDKey := key.NewNetworkKey("information-sequence:%s:information-id", newInput)
// Our test ID factory always returns the same ID. That way we are able to
// check for the ID being used during the test.
newID, err := newServiceCollection.ID().New()
if err != nil {
t.Fatal("expected", nil, "got", err)
}
informationSequenceKey := key.NewNetworkKey("information-id:%s:information-sequence", newID)
c := redigomock.NewConn()
c.Command("GET", "prefix:"+informationIDKey).ExpectError(redigo.ErrNil)
c.Command("SET", "prefix:"+informationIDKey, string(newID)).Expect("OK")
c.Command("SET", "prefix:"+informationSequenceKey, newInput).ExpectError(invalidConfigError)
newStorageCollection := testMustNewStorageCollectionWithConn(t, c)
// Set prepared storage to CLG we want to test.
newCLG.(*clg).StorageCollection = newStorageCollection
newCLG.(*clg).ServiceCollection = newServiceCollection
// Execute CLG.
err = newCLG.(*clg).calculate(newCtx, newInput)
if !IsInvalidConfig(err) {
t.Fatal("expected", true, "got", false)
}
}
func Test_CLG_Input_KnownInputSequence(t *testing.T) {
newCLG := MustNew()
newCtx := context.MustNew()
newStorageCollection := testMustNewStorageCollection(t)
// Create record for the test input.
informationID := "123"
newInput := "test input"
informationIDKey := key.NewNetworkKey("information-sequence:%s:information-id", newInput)
err := newStorageCollection.General().Set(informationIDKey, informationID)
if err != nil {
t.Fatal("expected", nil, "got", err)
}
// Set prepared storage to CLG we want to test.
newCLG.(*clg).StorageCollection = newStorageCollection
// Execute CLG.
err = newCLG.(*clg).calculate(newCtx, newInput)
if err != nil {
t.Fatal("expected", nil, "got", err)
}
// Check if the information ID was set to the context.
injectedInformationID, _ := newCtx.GetInformationID()
if informationID != injectedInformationID {
t.Fatal("expected", informationID, "got", injectedInformationID)
}
}
func Test_CLG_Sum(t *testing.T) {
testCases := []struct {
A float64
B float64
Expected float64
}{
{
A: 3.5,
B: 12.5,
Expected: 16,
},
{
A: 35.5,
B: 14.5,
Expected: 50,
},
{
A: -3.5,
B: 7.5,
Expected: 4,
},
{
A: 12.5,
B: 4.5,
Expected: 17,
},
{
A: 36.5,
B: 6.5,
Expected: 43,
},
{
A: 36,
B: 6.5,
Expected: 42.5,
},
{
A: 99.99,
B: 12.15,
Expected: 112.14,
},
{
A: 17,
B: 65,
Expected: 82,
},
}
newCLG := MustNew()
for i, testCase := range testCases {
f := newCLG.(*clg).calculate(context.MustNew(), testCase.A, testCase.B)
if f != testCase.Expected {
t.Fatal("case", i+1, "expected", testCase.Expected, "got", f)
}
}
}
// DefaultConfig provides a default configuration to create a new
// network payload object by best effort.
func DefaultConfig() Config {
newConfig := Config{
Args: nil,
Context: context.MustNew(),
Destination: "",
Sources: nil,
}
return newConfig
}
func Test_CLG_IsLesser(t *testing.T) {
testCases := []struct {
A float64
B float64
Expected bool
}{
{
A: 3.5,
B: 3.5,
Expected: false,
},
{
A: 12.5,
B: 3.5,
Expected: false,
},
{
A: 14.5,
B: 35.5,
Expected: true,
},
{
A: 7.5,
B: -3.5,
Expected: false,
},
{
A: 4.5,
B: 12.5,
Expected: true,
},
{
A: 65,
B: 17,
Expected: false,
},
{
A: 17,
B: 65,
Expected: true,
},
}
newCLG := MustNew()
for i, testCase := range testCases {
f := newCLG.(*clg).calculate(context.MustNew(), testCase.A, testCase.B)
if f != testCase.Expected {
t.Fatal("case", i+1, "expected", testCase.Expected, "got", f)
}
}
}
func Test_CLG_Subtract(t *testing.T) {
testCases := []struct {
A float64
B float64
Expected float64
}{
{
A: 3.5,
B: 12.5,
Expected: -9,
},
{
A: 35.5,
B: 14.5,
Expected: 21,
},
{
A: -3.5,
B: -7.5,
Expected: 4,
},
{
A: 12.5,
B: 4.5,
Expected: 8,
},
{
A: 36.5,
B: 6.5,
Expected: 30,
},
{
A: 11.11,
B: 10.10,
Expected: 1.0099999999999998,
},
}
newCLG := MustNew()
for i, testCase := range testCases {
f := newCLG.(*clg).calculate(context.MustNew(), testCase.A, testCase.B)
if f != testCase.Expected {
t.Fatal("case", i+1, "expected", testCase.Expected, "got", f)
}
}
}
func Test_CLG_Multiply(t *testing.T) {
testCases := []struct {
A float64
B float64
Expected float64
}{
{
A: 3.5,
B: 12.5,
Expected: 43.75,
},
{
A: 35.5,
B: 14.5,
Expected: 514.75,
},
{
A: -3.5,
B: 7.5,
Expected: -26.25,
},
{
A: 12.5,
B: 4.5,
Expected: 56.25,
},
{
A: 36.5,
B: 6.5,
Expected: 237.25,
},
{
A: 17,
B: 65,
Expected: 1105,
},
}
newCLG := MustNew()
for i, testCase := range testCases {
f := newCLG.(*clg).calculate(context.MustNew(), testCase.A, testCase.B)
if f != testCase.Expected {
t.Fatal("case", i+1, "expected", testCase.Expected, "got", f)
}
}
}
func Test_CLG_Input_DataProperlyStored(t *testing.T) {
newCLG := MustNew()
newCtx := context.MustNew()
newStorageCollection := testMustNewStorageCollection(t)
newServiceCollection := testMustNewServiceCollection(t)
// Note we do not create a record for the test input. This test is about an
// unknown input sequence.
newInput := "test input"
// Our test ID factory always returns the same ID. That way we are able to
// check for the ID being used during the test.
newID, err := newServiceCollection.ID().New()
if err != nil {
t.Fatal("expected", nil, "got", err)
}
// Set prepared storage to CLG we want to test.
newCLG.(*clg).ServiceCollection = newServiceCollection
newCLG.(*clg).StorageCollection = newStorageCollection
// Execute CLG.
err = newCLG.(*clg).calculate(newCtx, newInput)
if err != nil {
t.Fatal("expected", nil, "got", err)
}
informationIDKey := key.NewNetworkKey("information-sequence:%s:information-id", newInput)
storedID, err := newStorageCollection.General().Get(informationIDKey)
if err != nil {
t.Fatal("expected", nil, "got", err)
}
if storedID != string(newID) {
t.Fatal("expected", newID, "got", storedID)
}
informationSequenceKey := key.NewNetworkKey("information-id:%s:information-sequence", newID)
storedInput, err := newStorageCollection.General().Get(informationSequenceKey)
if err != nil {
t.Fatal("expected", nil, "got", err)
}
if storedInput != newInput {
t.Fatal("expected", newInput, "got", storedInput)
}
}
func Test_CLG_Divide(t *testing.T) {
testCases := []struct {
A float64
B float64
Expected float64
}{
{
A: 3.5,
B: 12.5,
Expected: 0.28,
},
{
A: 35.5,
B: 14.5,
Expected: 2.4482758620689653,
},
{
A: -3.5,
B: 7.5,
Expected: -0.4666666666666667,
},
{
A: 12.5,
B: 4.5,
Expected: 2.7777777777777777,
},
{
A: 36.5,
B: 6.5,
Expected: 5.615384615384615,
},
}
newCLG := MustNew()
for i, testCase := range testCases {
f := newCLG.(*clg).calculate(context.MustNew(), testCase.A, testCase.B)
if f != testCase.Expected {
t.Fatal("case", i+1, "expected", testCase.Expected, "got", f)
}
}
}
func Test_CLG_Input_IDServiceError(t *testing.T) {
newCLG := MustNew()
newCtx := context.MustNew()
newStorageCollection := testMustNewStorageCollection(t)
newServiceCollection := testMustNewErrorServiceCollection(t)
// Note we do not create a record for the test input. This test is about an
// unknown input sequence.
newInput := "test input"
// Set prepared storage to CLG we want to test.
newCLG.(*clg).ServiceCollection = newServiceCollection
newCLG.(*clg).StorageCollection = newStorageCollection
// Execute CLG.
err := newCLG.(*clg).calculate(newCtx, newInput)
if !IsInvalidConfig(err) {
t.Fatal("expected", true, "got", false)
}
}
func Test_CLG_Input_GetInformationIDError(t *testing.T) {
newCLG := MustNew()
newCtx := context.MustNew()
newInput := "test input"
informationIDKey := key.NewNetworkKey("information-sequence:%s:information-id", newInput)
// Prepare the storage connection to fake a returned error.
c := redigomock.NewConn()
c.Command("GET", "prefix:"+informationIDKey).ExpectError(invalidConfigError)
newStorageCollection := testMustNewStorageCollectionWithConn(t, c)
// Set prepared storage to CLG we want to test.
newCLG.SetStorageCollection(newStorageCollection)
// Execute CLG.
err := newCLG.(*clg).calculate(newCtx, newInput)
if !IsInvalidConfig(err) {
t.Fatal("expected", true, "got", false)
}
}
func Test_CLG_IsBetween(t *testing.T) {
testCases := []struct {
N float64
Min float64
Max float64
Expected bool
}{
{
N: 1,
Min: 2,
Max: 4,
Expected: false,
},
{
N: 2,
Min: 2,
Max: 4,
Expected: true,
},
{
N: 3,
Min: 2,
Max: 4,
Expected: true,
},
{
N: 4,
Min: 2,
Max: 4,
Expected: true,
},
{
N: 5,
Min: 2,
Max: 4,
Expected: false,
},
{
N: 35,
Min: -13,
Max: 518,
Expected: true,
},
{
N: -87,
Min: -413,
Max: -18,
Expected: true,
},
{
N: -7,
Min: -413,
Max: -18,
Expected: false,
},
{
N: -987,
Min: -413,
Max: -18,
Expected: false,
},
{
N: 1.8,
Min: 2.34,
Max: 4.944,
Expected: false,
},
{
N: 2.334,
Min: 2.2,
Max: 4.1,
Expected: true,
},
{
N: 3.9,
Min: 2.003,
Max: 4,
Expected: true,
},
{
N: 4,
Min: 2.22,
Max: 4.83,
Expected: true,
},
}
newCLG := MustNew()
for i, testCase := range testCases {
b := newCLG.(*clg).calculate(context.MustNew(), testCase.N, testCase.Min, testCase.Max)
if b != testCase.Expected {
t.Fatal("case", i+1, "expected", testCase.Expected, "got", b)
}
}
}
func (n *network) InputHandler(CLG systemspec.CLG, textInput objectspec.TextInput) error {
// In case the text request defines the echo flag, we overwrite the given CLG
// directly to the output CLG. This will cause the created network payload to
// be forwarded to the output CLG without indirection. Note that this should
// only be used for testing purposes to bypass more complex neural network
// activities to directly respond with the received input.
if textInput.GetEcho() {
var ok bool
CLG, ok = n.CLGs["output"]
if !ok {
return maskAnyf(clgNotFoundError, "name: %s", "output")
}
}
// Create new IDs for the new CLG tree and the input CLG.
clgTreeID, err := n.Service().ID().New()
if err != nil {
return maskAny(err)
}
behaviourID, err := n.Service().ID().New()
if err != nil {
return maskAny(err)
}
// Create a new context and adapt it using the information of the current scope.
ctx := context.MustNew()
ctx.SetBehaviourID(string(behaviourID))
ctx.SetCLGName(CLG.GetName())
ctx.SetCLGTreeID(string(clgTreeID))
ctx.SetExpectation(textInput.GetExpectation())
ctx.SetSessionID(textInput.GetSessionID())
// We transform the received text request to a network payload to have a
// conventional data structure within the neural network.
newNetworkPayloadConfig := networkpayload.DefaultConfig()
newNetworkPayloadConfig.Args = []reflect.Value{reflect.ValueOf(textInput.GetInput())}
newNetworkPayloadConfig.Context = ctx
newNetworkPayloadConfig.Destination = behaviourID
newNetworkPayloadConfig.Sources = []string{n.GetID()}
newNetworkPayload, err := networkpayload.New(newNetworkPayloadConfig)
if err != nil {
return maskAny(err)
}
// Write the new CLG tree ID to reference the input CLG ID and add the CLG
// tree ID to the new context.
firstBehaviourIDKey := key.NewNetworkKey("clg-tree-id:%s:first-behaviour-id", clgTreeID)
err = n.Storage().General().Set(firstBehaviourIDKey, string(behaviourID))
if err != nil {
return maskAny(err)
}
// Write the transformed network payload to the queue.
eventKey := key.NewNetworkKey("event:network-payload")
b, err := json.Marshal(newNetworkPayload)
if err != nil {
return maskAny(err)
}
err = n.Storage().General().PushToList(eventKey, string(b))
if err != nil {
return maskAny(err)
}
return nil
}