diff options
Diffstat (limited to 'vendor/github.com/skip2/go-qrcode/encoder_test.go')
| -rw-r--r-- | vendor/github.com/skip2/go-qrcode/encoder_test.go | 328 |
1 files changed, 328 insertions, 0 deletions
diff --git a/vendor/github.com/skip2/go-qrcode/encoder_test.go b/vendor/github.com/skip2/go-qrcode/encoder_test.go new file mode 100644 index 0000000..1bf74be --- /dev/null +++ b/vendor/github.com/skip2/go-qrcode/encoder_test.go @@ -0,0 +1,328 @@ +// go-qrcode +// Copyright 2014 Tom Harwood + +package qrcode + +import ( + "fmt" + "reflect" + "testing" + + bitset "github.com/skip2/go-qrcode/bitset" +) + +func TestClassifyDataMode(t *testing.T) { + type Test struct { + } + + tests := []struct { + data []byte + actual []segment + }{ + { + []byte{0x30}, + []segment{ + { + dataModeNumeric, + []byte{0x30}, + }, + }, + }, + { + []byte{0x30, 0x41, 0x42, 0x43, 0x20, 0x00, 0xf0, 0xf1, 0xf2, 0x31}, + []segment{ + { + dataModeNumeric, + []byte{0x30}, + }, + { + dataModeAlphanumeric, + []byte{0x41, 0x42, 0x43, 0x20}, + }, + { + dataModeByte, + []byte{0x00, 0xf0, 0xf1, 0xf2}, + }, + { + dataModeNumeric, + []byte{0x31}, + }, + }, + }, + } + + for _, test := range tests { + encoder := newDataEncoder(dataEncoderType1To9) + encoder.encode(test.data) + + if !reflect.DeepEqual(test.actual, encoder.actual) { + t.Errorf("Got %v, expected %v", encoder.actual, test.actual) + } + } +} + +func TestByteModeLengthCalculations(t *testing.T) { + tests := []struct { + dataEncoderType dataEncoderType + dataMode dataMode + numSymbols int + expectedLength int + }{} + + for i, test := range tests { + encoder := newDataEncoder(test.dataEncoderType) + var resultLength int + + resultLength, err := encoder.encodedLength(test.dataMode, test.numSymbols) + + if test.expectedLength == -1 { + if err == nil { + t.Errorf("Test %d: got length %d, expected error", i, resultLength) + } + } else if resultLength != test.expectedLength { + t.Errorf("Test %d: got length %d, expected length %d", i, resultLength, + test.expectedLength) + } + } +} + +func TestSingleModeEncodings(t *testing.T) { + tests := []struct { + dataEncoderType dataEncoderType + dataMode dataMode + data string + expected *bitset.Bitset + }{ + { + dataEncoderType1To9, + dataModeNumeric, + "01234567", + bitset.NewFromBase2String("0001 0000001000 0000001100 0101011001 1000011"), + }, + { + dataEncoderType1To9, + dataModeAlphanumeric, + "AC-42", + bitset.NewFromBase2String("0010 000000101 00111001110 11100111001 000010"), + }, + { + dataEncoderType1To9, + dataModeByte, + "123", + bitset.NewFromBase2String("0100 00000011 00110001 00110010 00110011"), + }, + { + dataEncoderType10To26, + dataModeByte, + "123", + bitset.NewFromBase2String("0100 00000000 00000011 00110001 00110010 00110011"), + }, + { + dataEncoderType27To40, + dataModeByte, + "123", + bitset.NewFromBase2String("0100 00000000 00000011 00110001 00110010 00110011"), + }, + } + + for _, test := range tests { + encoder := newDataEncoder(test.dataEncoderType) + encoded := bitset.New() + + encoder.encodeDataRaw([]byte(test.data), test.dataMode, encoded) + + if !test.expected.Equals(encoded) { + t.Errorf("For %s got %s, expected %s", test.data, encoded.String(), + test.expected.String()) + } + } +} + +type testModeSegment struct { + dataMode dataMode + numChars int +} + +func TestOptimiseEncoding(t *testing.T) { + tests := []struct { + dataEncoderType dataEncoderType + actual []testModeSegment + optimised []testModeSegment + }{ + // Coalescing multiple segments. + { + dataEncoderType1To9, + []testModeSegment{ + {dataModeAlphanumeric, 1}, // length = 4 + 9 + 6 = 19 bits + {dataModeNumeric, 1}, // length = 4 + 10 + 4 = 18 bits + {dataModeAlphanumeric, 1}, // 19 bits. + {dataModeNumeric, 1}, // 18 bits. + {dataModeAlphanumeric, 1}, // 19 bits. + // total = 93 bits. + }, + []testModeSegment{ + {dataModeAlphanumeric, 5}, // length = 4 + 9 + 22 + 6 = 41. + }, + }, + // Coalesing not necessary. + { + dataEncoderType1To9, + []testModeSegment{ + {dataModeAlphanumeric, 1}, + {dataModeNumeric, 20}, + }, + []testModeSegment{ + {dataModeAlphanumeric, 1}, + {dataModeNumeric, 20}, + }, + }, + // Switch to more general dataMode. + { + dataEncoderType1To9, + []testModeSegment{ + {dataModeAlphanumeric, 1}, + {dataModeByte, 1}, + {dataModeNumeric, 1}, + }, + []testModeSegment{ + {dataModeAlphanumeric, 1}, + {dataModeByte, 2}, + }, + }, + // https://www.google.com/123 + // BBBBBAAABBBABBBBBBABBBANNN + { + dataEncoderType1To9, + []testModeSegment{ + {dataModeByte, 5}, + {dataModeAlphanumeric, 3}, + {dataModeByte, 3}, + {dataModeAlphanumeric, 1}, + {dataModeByte, 6}, + {dataModeAlphanumeric, 1}, + {dataModeAlphanumeric, 4}, + {dataModeNumeric, 3}, + }, + []testModeSegment{ + {dataModeByte, 23}, + {dataModeNumeric, 3}, + }, + }, + // HTTPS://WWW.GOOGLE.COM/123 + // AAAAAAAAAAAAAAAAAAAAAAANNN + { + dataEncoderType1To9, + []testModeSegment{ + {dataModeAlphanumeric, 23}, + {dataModeNumeric, 3}, + }, + []testModeSegment{ + {dataModeAlphanumeric, 26}, + }, + }, + { + dataEncoderType27To40, + []testModeSegment{ + {dataModeByte, 1}, + {dataModeNumeric, 1}, + {dataModeByte, 1}, + {dataModeNumeric, 1}, + {dataModeByte, 1}, + {dataModeNumeric, 1}, + {dataModeByte, 1}, + {dataModeNumeric, 1}, + }, + []testModeSegment{ + {dataModeByte, 8}, + }, + }, + } + + for _, test := range tests { + numTotalChars := 0 + for _, v := range test.actual { + numTotalChars += v.numChars + } + + data := make([]byte, numTotalChars) + + i := 0 + for _, v := range test.actual { + for j := 0; j < v.numChars; j++ { + switch v.dataMode { + case dataModeNumeric: + data[i] = '1' + case dataModeAlphanumeric: + data[i] = 'A' + case dataModeByte: + data[i] = '#' + default: + t.Fatal("Unrecognised data mode") + } + + i++ + } + } + + encoder := newDataEncoder(test.dataEncoderType) + + _, err := encoder.encode(data) + + if err != nil { + t.Errorf("Got %s, expected valid encoding", err.Error()) + } else { + ok := true + + if len(encoder.optimised) != len(test.optimised) { + ok = false + } else { + for i, s := range test.optimised { + if encoder.optimised[i].dataMode != s.dataMode || + len(encoder.optimised[i].data) != s.numChars { + ok = false + break + } + } + } + + if !ok { + t.Errorf("got %s, expected %s", segmentsString(encoder.optimised), + testModeSegmentsString(test.optimised)) + } + } + } +} + +func testModeSegmentsString(segments []testModeSegment) string { + result := "[" + + for i, segment := range segments { + if i > 0 { + result += ", " + } + + result += fmt.Sprintf("%d*%s", segment.numChars, + dataModeString(segment.dataMode)) + } + + result += "]" + + return result +} + +func segmentsString(segments []segment) string { + result := "[" + + for i, segment := range segments { + if i > 0 { + result += ", " + } + + result += fmt.Sprintf("%d*%s", len(segment.data), + dataModeString(segment.dataMode)) + } + + result += "]" + + return result +} |