← Back to branch summary

~ubuntu-branches/ubuntu/utopic/golang/utopic

« back to all changes in this revision

Viewing changes to src/pkg/encoding/gob/encoder_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/encoding/gob/encoder_test.go
736
736
                t.Fatalf("expected %v got %v", data, newData)
737
737
        }
738
738
}
 
739
 
 
740
// A top-level nil pointer generates a panic with a helpful string-valued message.
 
741
func TestTopLevelNilPointer(t *testing.T) {
 
742
        errMsg := topLevelNilPanic(t)
 
743
        if errMsg == "" {
 
744
                t.Fatal("top-level nil pointer did not panic")
 
745
        }
 
746
        if !strings.Contains(errMsg, "nil pointer") {
 
747
                t.Fatal("expected nil pointer error, got:", errMsg)
 
748
        }
 
749
}
 
750
 
 
751
func topLevelNilPanic(t *testing.T) (panicErr string) {
 
752
        defer func() {
 
753
                e := recover()
 
754
                if err, ok := e.(string); ok {
 
755
                        panicErr = err
 
756
                }
 
757
        }()
 
758
        var ip *int
 
759
        buf := new(bytes.Buffer)
 
760
        if err := NewEncoder(buf).Encode(ip); err != nil {
 
761
                t.Fatal("error in encode:", err)
 
762
        }
 
763
        return
 
764
}
 
765
 
 
766
func TestNilPointerInsideInterface(t *testing.T) {
 
767
        var ip *int
 
768
        si := struct {
 
769
                I interface{}
 
770
        }{
 
771
                I: ip,
 
772
        }
 
773
        buf := new(bytes.Buffer)
 
774
        err := NewEncoder(buf).Encode(si)
 
775
        if err == nil {
 
776
                t.Fatal("expected error, got none")
 
777
        }
 
778
        errMsg := err.Error()
 
779
        if !strings.Contains(errMsg, "nil pointer") || !strings.Contains(errMsg, "interface") {
 
780
                t.Fatal("expected error about nil pointer and interface, got:", errMsg)
 
781
        }
 
782
}
 
783
 
 
784
type Bug4Public struct {
 
785
        Name   string
 
786
        Secret Bug4Secret
 
787
}
 
788
 
 
789
type Bug4Secret struct {
 
790
        a int // error: no exported fields.
 
791
}
 
792
 
 
793
// Test that a failed compilation doesn't leave around an executable encoder.
 
794
// Issue 3273.
 
795
func TestMutipleEncodingsOfBadType(t *testing.T) {
 
796
        x := Bug4Public{
 
797
                Name:   "name",
 
798
                Secret: Bug4Secret{1},
 
799
        }
 
800
        buf := new(bytes.Buffer)
 
801
        enc := NewEncoder(buf)
 
802
        err := enc.Encode(x)
 
803
        if err == nil {
 
804
                t.Fatal("first encoding: expected error")
 
805
        }
 
806
        buf.Reset()
 
807
        enc = NewEncoder(buf)
 
808
        err = enc.Encode(x)
 
809
        if err == nil {
 
810
                t.Fatal("second encoding: expected error")
 
811
        }
 
812
        if !strings.Contains(err.Error(), "no exported fields") {
 
813
                t.Errorf("expected error about no exported fields; got %v", err)
 
814
        }
 
815
}
 
816
 
 
817
// There was an error check comparing the length of the input with the
 
818
// length of the slice being decoded. It was wrong because the next
 
819
// thing in the input might be a type definition, which would lead to
 
820
// an incorrect length check.  This test reproduces the corner case.
 
821
 
 
822
type Z struct {
 
823
}
 
824
 
 
825
func Test29ElementSlice(t *testing.T) {
 
826
        Register(Z{})
 
827
        src := make([]interface{}, 100) // Size needs to be bigger than size of type definition.
 
828
        for i := range src {
 
829
                src[i] = Z{}
 
830
        }
 
831
        buf := new(bytes.Buffer)
 
832
        err := NewEncoder(buf).Encode(src)
 
833
        if err != nil {
 
834
                t.Fatalf("encode: %v", err)
 
835
                return
 
836
        }
 
837
 
 
838
        var dst []interface{}
 
839
        err = NewDecoder(buf).Decode(&dst)
 
840
        if err != nil {
 
841
                t.Errorf("decode: %v", err)
 
842
                return
 
843
        }
 
844
}