deterministic_test.go

Documentation: github.com/gogo/protobuf/test/deterministic

     1  // Protocol Buffers for Go with Gadgets
     2  //
     3  // Copyright (c) 2018, The GoGo Authors. All rights reserved.
     4  // http://github.com/gogo/protobuf
     5  //
     6  // Redistribution and use in source and binary forms, with or without
     7  // modification, are permitted provided that the following conditions are
     8  // met:
     9  //
    10  //     * Redistributions of source code must retain the above copyright
    11  // notice, this list of conditions and the following disclaimer.
    12  //     * Redistributions in binary form must reproduce the above
    13  // copyright notice, this list of conditions and the following disclaimer
    14  // in the documentation and/or other materials provided with the
    15  // distribution.
    16  //
    17  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    18  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    19  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    20  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    21  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    22  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    23  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    24  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    25  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    26  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    27  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    28  
    29  package deterministic
    30  
    31  import (
    32  	"bytes"
    33  	"github.com/gogo/protobuf/proto"
    34  	"testing"
    35  )
    36  
    37  func getTestMap() map[string]string {
    38  	return map[string]string{
    39  		"a": "1",
    40  		"b": "2",
    41  		"c": "3",
    42  		"d": "4",
    43  		"e": "5",
    44  		"f": "6",
    45  		"g": "7",
    46  		"h": "8",
    47  		"i": "9",
    48  		"j": "10",
    49  		"k": "11",
    50  		"l": "12",
    51  		"m": "13",
    52  		"n": "14",
    53  	}
    54  
    55  }
    56  
    57  func TestOrderedMap(t *testing.T) {
    58  	var b proto.Buffer
    59  	m := getTestMap()
    60  	in := &OrderedMap{
    61  		StringMap: m,
    62  	}
    63  	if err := b.Marshal(in); err != nil {
    64  		t.Fatalf("Marshal failed: %v", err)
    65  	}
    66  	data1 := b.Bytes()
    67  	out := &OrderedMap{}
    68  	if err := proto.Unmarshal(data1, out); err != nil {
    69  		t.Fatal(err)
    70  	}
    71  	if err := in.VerboseEqual(out); err != nil {
    72  		t.Fatal(err)
    73  	}
    74  	data2, err := proto.Marshal(in)
    75  	if err != nil {
    76  		t.Fatal(err)
    77  	}
    78  	if bytes.Compare(data1, data2) != 0 {
    79  		t.Fatal("byte arrays are not the same\n", data1, "\n", data2)
    80  	}
    81  }
    82  
    83  func TestUnorderedMap(t *testing.T) {
    84  	m := getTestMap()
    85  	in := &UnorderedMap{
    86  		StringMap: m,
    87  	}
    88  	var b proto.Buffer
    89  	b.SetDeterministic(true)
    90  	if err := b.Marshal(in); err == nil {
    91  		t.Fatalf("Expected Marshal to return error rejecting deterministic flag")
    92  	}
    93  }
    94  
    95  func TestMapNoMarshaler(t *testing.T) {
    96  	m := getTestMap()
    97  	in := &MapNoMarshaler{
    98  		StringMap: m,
    99  	}
   100  
   101  	var b1 proto.Buffer
   102  	b1.SetDeterministic(true)
   103  	if err := b1.Marshal(in); err != nil {
   104  		t.Fatalf("Marshal failed: %v", err)
   105  	}
   106  	data1 := b1.Bytes()
   107  
   108  	out := &MapNoMarshaler{}
   109  	err := proto.Unmarshal(data1, out)
   110  	if err != nil {
   111  		t.Fatal(err)
   112  	}
   113  	if err := in.VerboseEqual(out); err != nil {
   114  		t.Fatal(err)
   115  	}
   116  
   117  	var b2 proto.Buffer
   118  	b2.SetDeterministic(true)
   119  	if err := b2.Marshal(in); err != nil {
   120  		t.Fatalf("Marshal failed: %v", err)
   121  	}
   122  	data2 := b2.Bytes()
   123  
   124  	if bytes.Compare(data1, data2) != 0 {
   125  		t.Fatal("byte arrays are not the same:\n", data1, "\n", data2)
   126  	}
   127  }
   128  
   129  func TestOrderedNestedMap(t *testing.T) {
   130  	var b proto.Buffer
   131  	in := &NestedOrderedMap{
   132  		StringMap: getTestMap(),
   133  		NestedMap: &NestedMap1{
   134  			NestedStringMap: getTestMap(),
   135  		},
   136  	}
   137  	if err := b.Marshal(in); err != nil {
   138  		t.Fatalf("Marshal failed: %v", err)
   139  	}
   140  	data1 := b.Bytes()
   141  	out := &NestedOrderedMap{}
   142  	if err := proto.Unmarshal(data1, out); err != nil {
   143  		t.Fatal(err)
   144  	}
   145  	if err := in.VerboseEqual(out); err != nil {
   146  		t.Fatal(err)
   147  	}
   148  	data2, err := proto.Marshal(in)
   149  	if err != nil {
   150  		t.Fatal(err)
   151  	}
   152  	if bytes.Compare(data1, data2) != 0 {
   153  		t.Fatal("byte arrays are not the same\n", data1, "\n", data2)
   154  	}
   155  }
   156  
   157  func TestUnorderedNestedMap(t *testing.T) {
   158  	in := &NestedUnorderedMap{
   159  		StringMap: getTestMap(),
   160  		NestedMap: &NestedMap2{
   161  			NestedStringMap: getTestMap(),
   162  		},
   163  	}
   164  	var b proto.Buffer
   165  	b.SetDeterministic(true)
   166  	if err := b.Marshal(in); err == nil {
   167  		t.Fatalf("Expected Marshal to return error rejecting deterministic flag")
   168  	}
   169  }
   170  
   171  func TestOrderedNestedStructMap(t *testing.T) {
   172  	var b proto.Buffer
   173  	m := getTestMap()
   174  	in := &NestedMap1{
   175  		NestedStringMap: m,
   176  	}
   177  	if err := b.Marshal(in); err != nil {
   178  		t.Fatalf("Marshal failed: %v", err)
   179  	}
   180  	data1 := b.Bytes()
   181  	out := &NestedMap1{}
   182  	if err := proto.Unmarshal(data1, out); err != nil {
   183  		t.Fatal(err)
   184  	}
   185  	if err := in.VerboseEqual(out); err != nil {
   186  		t.Fatal(err)
   187  	}
   188  	data2, err := proto.Marshal(in)
   189  	if err != nil {
   190  		t.Fatal(err)
   191  	}
   192  	if bytes.Compare(data1, data2) != 0 {
   193  		t.Fatal("byte arrays are not the same\n", data1, "\n", data2)
   194  	}
   195  }
   196  
   197  func TestUnorderedNestedStructMap(t *testing.T) {
   198  	m := getTestMap()
   199  	in := &NestedMap2{
   200  		NestedStringMap: m,
   201  	}
   202  	var b proto.Buffer
   203  	b.SetDeterministic(true)
   204  	if err := b.Marshal(in); err == nil {
   205  		t.Fatalf("Expected Marshal to return error rejecting deterministic flag")
   206  	}
   207  }
   208
View as plain text