Exemple #1
0
func TestUnmarshal_HeaderTrailer(t *testing.T) {
	type Header struct {
		StringField string `fix:"49"`
	}
	type Trailer struct {
		IntField int `fix:"89"`
	}

	type Message struct {
		FIXMsgType  string `fix:"0"`
		StringField string `fix:"112"`
		Header
		Trailer
	}

	fixMsg := quickfix.NewMessage()
	fixMsg.Header.SetField(quickfix.Tag(35), quickfix.FIXString("0"))
	fixMsg.Header.SetField(quickfix.Tag(49), quickfix.FIXString("hello"))
	fixMsg.Body.SetField(quickfix.Tag(112), quickfix.FIXString("world"))
	fixMsg.Trailer.SetField(quickfix.Tag(89), quickfix.FIXInt(3))

	var msgOut Message
	quickfix.Unmarshal(fixMsg, &msgOut)

	if msgOut.Header.StringField != "hello" {
		t.Errorf("Expected '%v' got '%v'", "hello", msgOut.Header.StringField)
	}
	if msgOut.Trailer.IntField != 3 {
		t.Errorf("Expected '%v' got '%v'", 3, msgOut.Trailer.IntField)
	}

}
Exemple #2
0
func TestUnmarshal_Components(t *testing.T) {
	type Component1 struct {
		StringField string `fix:"8"`
	}
	type Component2 struct {
		IntField int `fix:"1"`
	}

	type Message struct {
		FIXMsgType string `fix:"0"`
		Component1
		StringField string `fix:"112"`
		*Component2
	}

	fixMsg := quickfix.NewMessage()
	fixMsg.Body.SetField(quickfix.Tag(8), quickfix.FIXString("hello"))
	fixMsg.Body.SetField(quickfix.Tag(112), quickfix.FIXString("world"))

	var msgOut Message
	quickfix.Unmarshal(fixMsg, &msgOut)

	if msgOut.Component1.StringField != "hello" {
		t.Errorf("Expected '%v' got '%v'", "hello", msgOut.Component1.StringField)
	}

	if msgOut.StringField != "world" {
		t.Errorf("Expected '%v' got '%v'", "world", msgOut.StringField)
	}
}
Exemple #3
0
func TestUnmarshal_LiteralsOptional(t *testing.T) {
	type Message struct {
		FIXMsgType           string     `fix:"0"`
		StringPtrField       *string    `fix:"112"`
		UnsetStringPtrField  *string    `fix:"113"`
		IntPtrField          *int       `fix:"114"`
		BoolPtrField         *bool      `fix:"115"`
		FloatPtrField        *float64   `fix:"116"`
		UTCTimestampPtrField *time.Time `fix:"117"`
	}

	fixMsg := quickfix.NewMessage()
	fixMsg.Body.SetField(quickfix.Tag(112), quickfix.FIXString("world"))
	fixMsg.Body.SetField(quickfix.Tag(114), quickfix.FIXInt(3))
	fixMsg.Body.SetField(quickfix.Tag(115), quickfix.FIXBoolean(false))
	fixMsg.Body.SetField(quickfix.Tag(116), quickfix.FIXFloat(500.123))
	tVal, _ := time.Parse("2006-Jan-02", "2014-Jun-16")
	fixMsg.Body.SetField(quickfix.Tag(117), quickfix.FIXUTCTimestamp{Value: tVal})

	var msgOut Message
	quickfix.Unmarshal(fixMsg, &msgOut)

	var tests = []struct {
		testName      string
		expectNil     bool
		actualIsNil   bool
		expectedDeref interface{}
		actualDeref   interface{}
	}{
		{"set string ptr", false, msgOut.StringPtrField == nil, "world", *msgOut.StringPtrField},
		{"unset string ptr", true, msgOut.UnsetStringPtrField == nil, "", "unset"},
		{"int ptr", false, msgOut.IntPtrField == nil, 3, *msgOut.IntPtrField},
		{"bool ptr", false, msgOut.BoolPtrField == nil, false, *msgOut.BoolPtrField},
		{"float ptr", false, msgOut.FloatPtrField == nil, 500.123, *msgOut.FloatPtrField},
		{"timestamp ptr", false, msgOut.UTCTimestampPtrField == nil, tVal, *msgOut.UTCTimestampPtrField},
	}

	for _, test := range tests {
		if test.expectNil {
			if !test.actualIsNil {
				t.Errorf("%v: Expected nil not %v", test.testName, test.actualDeref)
			}
			continue
		}

		if test.actualIsNil {
			t.Errorf("%v: Did not expect nil", test.testName)
			continue
		}

		if test.expectedDeref != test.actualDeref {
			t.Errorf("Expected '%v' got '%v'", test.expectedDeref, test.actualDeref)
		}
	}
}
Exemple #4
0
func TestUnmarshal_RepeatingGroups(t *testing.T) {
	type Group1 struct {
		StringField1 string  `fix:"8"`
		StringField2 *string `fix:"9"`
	}

	type Group2 struct {
		IntField1 int `fix:"1"`
		IntField2 int `fix:"2"`
	}

	type Message struct {
		FIXMsgType  string   `fix:"0"`
		GroupField1 []Group1 `fix:"100"`
		StringField string   `fix:"112"`
		GroupField2 []Group2 `fix:"101"`
	}

	fixMsg := quickfix.NewMessage()
	fixMsg.Body.SetField(quickfix.Tag(112), quickfix.FIXString("world"))

	group1Template := quickfix.GroupTemplate{
		quickfix.GroupElement(quickfix.Tag(8)),
		quickfix.GroupElement(quickfix.Tag(9)),
	}

	group1 := quickfix.RepeatingGroup{Tag: quickfix.Tag(100), GroupTemplate: group1Template}
	group1.Add().SetField(quickfix.Tag(8), quickfix.FIXString("hello")).SetField(quickfix.Tag(9), quickfix.FIXString("world"))
	group1.Add().SetField(quickfix.Tag(8), quickfix.FIXString("goodbye"))
	group1.Add().SetField(quickfix.Tag(8), quickfix.FIXString("OHHAI")).SetField(quickfix.Tag(9), quickfix.FIXString("world"))
	fixMsg.Body.SetGroup(group1)

	var msgOut Message
	quickfix.Unmarshal(fixMsg, &msgOut)

	if msgOut.StringField != "world" {
		t.Errorf("Expected '%v' got '%v'", "world", msgOut.StringField)
	}

	if len(msgOut.GroupField1) != 3 {
		t.Errorf("Expected group size '%v' got '%v'", 3, len(msgOut.GroupField1))
	}

	if msgOut.GroupField1[0].StringField1 != "hello" {
		t.Errorf("Expected %v got %v", "hello", msgOut.GroupField1[0].StringField1)
	}

	if *(msgOut.GroupField1[0].StringField2) != "world" {
		t.Errorf("Expected %v got %v", "world", *(msgOut.GroupField1[0].StringField2))
	}

	if msgOut.GroupField1[1].StringField1 != "goodbye" {
		t.Errorf("Expected %v got %v", "goodbye", msgOut.GroupField1[1].StringField1)
	}

	if msgOut.GroupField1[1].StringField2 != nil {
		t.Errorf("Expected stringfield 2 to be nil, got %v", *(msgOut.GroupField1[1].StringField2))
	}
}
Exemple #5
0
func TestMarshal_LiteralsOptional(t *testing.T) {
	type Message struct {
		FIXMsgType          string   `fix:"0"`
		StringPtrField      *string  `fix:"112"`
		UnsetStringPtrField *string  `fix:"113"`
		IntPtrField         *int     `fix:"115"`
		BoolPtrField        *bool    `fix:"117"`
		FloatPtrField       *float64 `fix:"119"`
	}

	strVal := "hello"
	intVal := 42
	boolVal := false
	floatVal := 456.123
	m := Message{
		StringPtrField: &strVal,
		IntPtrField:    &intVal,
		BoolPtrField:   &boolVal,
		FloatPtrField:  &floatVal,
	}
	fixMsg := quickfix.Marshal(m)

	var tests = []struct {
		tag        quickfix.Tag
		fieldValue quickfix.FieldValue
		fieldSet   bool
		expected   []byte
	}{
		{quickfix.Tag(112), new(quickfix.FIXString), true, []byte("hello")},
		{quickfix.Tag(113), new(quickfix.FIXString), false, []byte{}},
		{quickfix.Tag(115), new(quickfix.FIXInt), true, []byte("42")},
		{quickfix.Tag(117), new(quickfix.FIXBoolean), true, []byte("N")},
		{quickfix.Tag(119), new(quickfix.FIXFloat), true, []byte("456.123")},
	}

	for _, test := range tests {
		if !test.fieldSet {
			if fixMsg.Body.Has(test.tag) {
				t.Error("Unexpected field for tag", test.tag)
			}
			continue
		}

		if err := fixMsg.Body.GetField(test.tag, test.fieldValue); err != nil {
			t.Error("Unexpected error", err)
		}

		if !bytes.Equal(test.expected, test.fieldValue.Write()) {
			t.Errorf("Expected %s got %s", test.expected, test.fieldValue.Write())
		}
	}
}
Exemple #6
0
func TestMarshal_Components(t *testing.T) {
	type Component1 struct {
		StringField string `fix:"8"`
	}
	type Component2 struct {
		IntField int `fix:"1"`
	}

	type Message struct {
		FIXMsgType string `fix:"0"`
		Component1
		StringField string `fix:"112"`
		*Component2
	}

	m := Message{
		Component1:  Component1{StringField: "hello"},
		StringField: "world",
	}
	fixMsg := quickfix.Marshal(m)

	var tests = []struct {
		tag        quickfix.Tag
		fieldValue quickfix.FieldValue
		fieldSet   bool
		expected   []byte
	}{
		{quickfix.Tag(8), new(quickfix.FIXString), true, []byte("hello")},
		{quickfix.Tag(1), new(quickfix.FIXInt), false, []byte{}},
		{quickfix.Tag(112), new(quickfix.FIXString), true, []byte("world")},
	}

	for _, test := range tests {
		if !test.fieldSet {
			if fixMsg.Body.Has(test.tag) {
				t.Error("Unexpected field for tag", test.tag)
			}
			continue
		}

		if err := fixMsg.Body.GetField(test.tag, test.fieldValue); err != nil {
			t.Error("Unexpected error", err)
			continue
		}

		if !bytes.Equal(test.expected, test.fieldValue.Write()) {
			t.Errorf("Expected %s got %s", test.expected, test.fieldValue.Write())
		}
	}
}
Exemple #7
0
func TestMarshal_HeaderTrailer(t *testing.T) {
	type Header struct {
		StringField string `fix:"49"`
	}
	type Trailer struct {
		IntField int `fix:"89"`
	}

	type Message struct {
		FIXMsgType  string `fix:"0"`
		StringField string `fix:"112"`
		Header
		Trailer
	}

	m := Message{
		Header:      Header{StringField: "hello"},
		StringField: "world",
		Trailer:     Trailer{IntField: 3},
	}
	fixMsg := quickfix.Marshal(m)

	var tests = []struct {
		tag        quickfix.Tag
		fieldValue quickfix.FieldValue
		fixMsgPart quickfix.FieldMap
		expected   []byte
	}{
		{quickfix.Tag(35), new(quickfix.FIXString), fixMsg.Header, []byte("0")},
		{quickfix.Tag(49), new(quickfix.FIXString), fixMsg.Header, []byte("hello")},
		{quickfix.Tag(112), new(quickfix.FIXString), fixMsg.Body, []byte("world")},
		{quickfix.Tag(89), new(quickfix.FIXInt), fixMsg.Trailer, []byte("3")},
	}

	for _, test := range tests {
		if err := test.fixMsgPart.GetField(test.tag, test.fieldValue); err != nil {
			t.Error("Unexpected error", err)
		}

		if !bytes.Equal(test.expected, test.fieldValue.Write()) {
			t.Errorf("Expected %s got %s", test.expected, test.fieldValue.Write())
		}
	}
}
Exemple #8
0
func TestUnmarshal_Literals(t *testing.T) {
	type Message struct {
		FIXMsgType        string    `fix:"0"`
		StringField       string    `fix:"114"`
		IntField          int       `fix:"115"`
		UnsetIntField     int       `fix:"116"`
		BoolField         bool      `fix:"117"`
		FloatField        float64   `fix:"118"`
		UTCTimestampField time.Time `fix:"119"`
	}

	fixMsg := quickfix.NewMessage()
	fixMsg.Body.SetField(quickfix.Tag(114), quickfix.FIXString("world"))
	fixMsg.Body.SetField(quickfix.Tag(115), quickfix.FIXInt(3))
	fixMsg.Body.SetField(quickfix.Tag(117), quickfix.FIXBoolean(true))
	fixMsg.Body.SetField(quickfix.Tag(118), quickfix.FIXFloat(500.123))
	tVal, _ := time.Parse("2006-Jan-02", "2014-Jun-16")
	fixMsg.Body.SetField(quickfix.Tag(119), quickfix.FIXUTCTimestamp{Value: tVal})

	var msgOut Message
	quickfix.Unmarshal(fixMsg, &msgOut)

	var tests = []struct {
		expected interface{}
		actual   interface{}
	}{
		{"world", msgOut.StringField},
		{3, msgOut.IntField},
		{0, msgOut.UnsetIntField},
		{true, msgOut.BoolField},
		{500.123, msgOut.FloatField},
		{tVal, msgOut.UTCTimestampField},
	}

	for _, test := range tests {
		if test.expected != test.actual {
			t.Errorf("Expected %v got %v", test.expected, test.actual)
		}
	}
}
Exemple #9
0
func TestMarshal_Literals(t *testing.T) {
	type Message struct {
		FIXMsgType        string    `fix:"0"`
		StringField       string    `fix:"114"`
		IntField          int       `fix:"115"`
		UnsetIntField     int       `fix:"116"`
		BoolField         bool      `fix:"117"`
		FloatField        float64   `fix:"118"`
		UTCTimestampField time.Time `fix:"119"`
	}

	tVal, _ := time.Parse("2006-Jan-02", "2014-Jun-16")

	m := Message{
		StringField:       "world",
		IntField:          5,
		BoolField:         true,
		FloatField:        100.02,
		UTCTimestampField: tVal,
	}
	fixMsg := quickfix.Marshal(m)

	var tests = []struct {
		tag        quickfix.Tag
		fieldValue quickfix.FieldValue
		expected   []byte
	}{
		{quickfix.Tag(114), new(quickfix.FIXString), []byte("world")},
		{quickfix.Tag(115), new(quickfix.FIXInt), []byte("5")},
		{quickfix.Tag(116), new(quickfix.FIXInt), []byte("0")},
		{quickfix.Tag(117), new(quickfix.FIXBoolean), []byte("Y")},
		{quickfix.Tag(118), new(quickfix.FIXFloat), []byte("100.02")},
		{quickfix.Tag(119), new(quickfix.FIXUTCTimestamp), []byte("20140616-00:00:00.000")},
	}

	for _, test := range tests {
		if err := fixMsg.Body.GetField(test.tag, test.fieldValue); err != nil {
			t.Error("Unexpected error", err)
		}

		if !bytes.Equal(test.expected, test.fieldValue.Write()) {
			t.Errorf("Expected %s got %s", test.expected, test.fieldValue.Write())
		}
	}
}
Exemple #10
0
func TestMarshal_RepeatingGroups(t *testing.T) {
	type Group1 struct {
		StringField1 string  `fix:"8"`
		StringField2 *string `fix:"9"`
	}

	type Group2 struct {
		IntField1 int `fix:"1"`
		IntField2 int `fix:"2"`
	}

	type Message struct {
		FIXMsgType  string   `fix:"0"`
		GroupField1 []Group1 `fix:"100"`
		StringField string   `fix:"112"`
		GroupField2 []Group2 `fix:"101"`
	}

	s := "world"
	m := Message{
		GroupField1: []Group1{Group1{StringField1: "hello", StringField2: &s}, Group1{StringField1: "goodbye"}, Group1{StringField1: "OHHAI", StringField2: &s}},
		StringField: "world",
		GroupField2: []Group2{Group2{IntField1: 1, IntField2: 42}},
	}
	fixMsg := quickfix.Marshal(m)

	group1Template := quickfix.GroupTemplate{
		quickfix.GroupElement(quickfix.Tag(8)),
		quickfix.GroupElement(quickfix.Tag(9)),
	}

	group2Template := quickfix.GroupTemplate{
		quickfix.GroupElement(quickfix.Tag(1)),
		quickfix.GroupElement(quickfix.Tag(2)),
	}

	var tests = []struct {
		groupTag          quickfix.Tag
		expectedGroupSize int
		template          quickfix.GroupTemplate
	}{
		{quickfix.Tag(100), 3, group1Template},
		{quickfix.Tag(101), 1, group2Template},
	}

	for _, test := range tests {
		if !fixMsg.Body.Has(test.groupTag) {
			t.Errorf("Expected tag %v", test.groupTag)
			continue
		}

		groupField := quickfix.RepeatingGroup{Tag: test.groupTag, GroupTemplate: test.template}
		if err := fixMsg.Body.GetGroup(&groupField); err != nil {
			t.Error("Unexpected error", err)
			continue
		}

		if len(groupField.Groups) != test.expectedGroupSize {
			t.Errorf("Expected group %v to have size %v, got %v", test.groupTag, test.expectedGroupSize, len(groupField.Groups))
		}
	}
}