vendor/github.com/golang/protobuf/protoc-gen-go/generator/name_test.go

   1 // Go support for Protocol Buffers - Google's data interchange format
   2 //
   3 // Copyright 2013 The Go Authors.  All rights reserved.
   4 // https://github.com/golang/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 //     * Neither the name of Google Inc. nor the names of its
  17 // contributors may be used to endorse or promote products derived from
  18 // this software without specific prior written permission.
  19 //
  20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31
  32 package generator
  33
  34 import (
  35         "testing"
  36
  37         "github.com/golang/protobuf/protoc-gen-go/descriptor"
  38 )
  39
  40 func TestCamelCase(t *testing.T) {
  41         tests := []struct {
  42                 in, want string
  43         }{
  44                 {"one", "One"},
  45                 {"one_two", "OneTwo"},
  46                 {"_my_field_name_2", "XMyFieldName_2"},
  47                 {"Something_Capped", "Something_Capped"},
  48                 {"my_Name", "My_Name"},
  49                 {"OneTwo", "OneTwo"},
  50                 {"_", "X"},
  51                 {"_a_", "XA_"},
  52         }
  53         for _, tc := range tests {
  54                 if got := CamelCase(tc.in); got != tc.want {
  55                         t.Errorf("CamelCase(%q) = %q, want %q", tc.in, got, tc.want)
  56                 }
  57         }
  58 }
  59
  60 func TestGoPackageOption(t *testing.T) {
  61         tests := []struct {
  62                 in           string
  63                 impPath, pkg string
  64                 ok           bool
  65         }{
  66                 {"", "", "", false},
  67                 {"foo", "", "foo", true},
  68                 {"github.com/golang/bar", "github.com/golang/bar", "bar", true},
  69                 {"github.com/golang/bar;baz", "github.com/golang/bar", "baz", true},
  70         }
  71         for _, tc := range tests {
  72                 d := &FileDescriptor{
  73                         FileDescriptorProto: &descriptor.FileDescriptorProto{
  74                                 Options: &descriptor.FileOptions{
  75                                         GoPackage: &tc.in,
  76                                 },
  77                         },
  78                 }
  79                 impPath, pkg, ok := d.goPackageOption()
  80                 if impPath != tc.impPath || pkg != tc.pkg || ok != tc.ok {
  81                         t.Errorf("go_package = %q => (%q, %q, %t), want (%q, %q, %t)", tc.in,
  82                                 impPath, pkg, ok, tc.impPath, tc.pkg, tc.ok)
  83                 }
  84         }
  85 }
  86
  87 func TestUnescape(t *testing.T) {
  88         tests := []struct {
  89                 in   string
  90                 out  string
  91         }{
  92                 // successful cases, including all kinds of escapes
  93                 {"", ""},
  94                 {"foo bar baz frob nitz", "foo bar baz frob nitz"},
  95                 {`\000\001\002\003\004\005\006\007`, string([]byte{0, 1, 2, 3, 4, 5, 6, 7})},
  96                 {`\a\b\f\n\r\t\v\\\?\'\"`, string([]byte{'\a', '\b', '\f', '\n', '\r', '\t', '\v', '\\', '?', '\'', '"'})},
  97                 {`\x10\x20\x30\x40\x50\x60\x70\x80`, string([]byte{16, 32, 48, 64, 80, 96, 112, 128})},
  98                 // variable length octal escapes
  99                 {`\0\018\222\377\3\04\005\6\07`, string([]byte{0, 1, '8', 0222, 255, 3, 4, 5, 6, 7})},
 100                 // malformed escape sequences left as is
 101                 {"foo \\g bar", "foo \\g bar"},
 102                 {"foo \\xg0 bar", "foo \\xg0 bar"},
 103                 {"\\", "\\"},
 104                 {"\\x", "\\x"},
 105                 {"\\xf", "\\xf"},
 106                 {"\\777", "\\777"}, // overflows byte
 107         }
 108         for _, tc := range tests {
 109                 s := unescape(tc.in)
 110                 if s != tc.out {
 111                         t.Errorf("doUnescape(%q) = %q; should have been %q", tc.in, s, tc.out)
 112                 }
 113         }
 114 }