t.Fatalf("unexpected: %v %d %v", err, n, buf)
	}
	if n, err := r.Read(buf); err != io.ErrShortBuffer && n != 1 && bytes.Equal(buf, []byte{0x02}) {
		t.Fatalf("unexpected: %v %d %v", err, n, buf)
	}
	// read the remaining frame
	buf = make([]byte, 2)
	if n, err := r.Read(buf); err != nil && n != 2 && bytes.Equal(buf, []byte{0x03, 0x04}) {

type F func(F)

func _() {
	var i F
	var j func(F)

	f(i, j)
	f(j, i)
}

// example from issue
func g[T interface{ Equal(T) bool }](a, b T) {}

type I interface{ Equal(I) bool }

func _() {
	var i I
	var j interface{ Equal(I) bool }

	g(i, j)
	g(j, i)

            LibraryBinaryIdentifier projectComponentIdentifier = (LibraryBinaryIdentifier) identifier;
            return Objects.equal(projectComponentIdentifier.getProjectPath(), projectPath)
                && Objects.equal(projectComponentIdentifier.getLibraryName(), libraryName)
                && Objects.equal(projectComponentIdentifier.getVariant(), variant);
        }

        return false;
    }

    @Override

      fail("Should fail on null equal object");
    } catch (NullPointerException e) {
    }
  }

  /** Test adding null equal object yields error */
  public void testAddNullEqualObject() {
    try {
      equalsTester.addEqualityGroup(reference, (Object[]) null);
      fail("Should fail on null equal object");
    } catch (NullPointerException e) {
    }
  }

  /**

	if x.Equal(expected) != 1 {
		t.Errorf("%+v != %+v", x, expected)
	}
}

func TestModAdd(t *testing.T) {
	m := modulusFromBytes([]byte{13})
	x := &Nat{[]uint{6}}
	y := &Nat{[]uint{7}}
	x.Add(y, m)
	expected := &Nat{[]uint{0}}
	if x.Equal(expected) != 1 {
		t.Errorf("%+v != %+v", x, expected)
	}
	x.Add(y, m)
	expected = &Nat{[]uint{7}}
	if x.Equal(expected) != 1 {

func equal(t *testing.T, f1, f2 reflect.Value) bool {
	switch f1.Type().Kind() {
	case reflect.Slice:
		if f1.Len() != f2.Len() {
			return false
		}
		for i := 0; i < f1.Len(); i++ {
			if !equal(t, f1.Index(i), f2.Index(i)) {
				return false
			}
		}
		return true
	case reflect.Struct:
		nf := f1.Type().NumField()
		for i := 0; i < nf; i++ {
			if !equal(t, f1.Field(i), f2.Field(i)) {
				return false
			}
		}

	checkRhs.fromP1xP1(tmpP1xP1)
	if checkLhs.Equal(checkRhs) != 1 {
		t.Error("B + B != [2]B")
	}
	checkOnCurve(t, checkLhs, checkRhs)

	checkLhs.Subtract(B, B)
	Bneg := new(Point).Negate(B)
	checkRhs.Add(B, Bneg)
	if checkLhs.Equal(checkRhs) != 1 {
		t.Error("B - B != B + (-B)")
	}
	if I.Equal(checkLhs) != 1 {
		t.Error("B - B != 0")
	}
	if I.Equal(checkRhs) != 1 {
		t.Error("B + (-B) != 0")
	}

	assert.Equal(t, len(fds), 1)
	// in theory we should close the fd, but it's just a test..

	assert.Equal(t, m.Payload.(*zdsapi.WorkloadRequest_Add).Add.Uid, uid)
	// send ack so the server doesn't wait for us.
	sendAck(ztunClient)

	// second message should be the snap sent message
	m, fds = readRequest(t, ztunClient)
	assert.Equal(t, len(fds), 0)

		} else if locality.Region == "region1" && locality.SubZone == "subzone2" {
			g.Expect(localityLbEndpoint.LoadBalancingWeight.GetValue()).To(Equal(uint32(17)))
			g.Expect(localityLbEndpoint.LbEndpoints[0].LoadBalancingWeight.GetValue()).To(Equal(uint32(20)))
		} else if locality.Region == "region2" {
			g.Expect(localityLbEndpoint.LoadBalancingWeight.GetValue()).To(Equal(uint32(50)))

		sandboxedNetNS, err = netns.Get()
		assert.NoError(t, err)
		return nil
	}))
	after := file.AsStringOrFail(t, "/etc/nsswitch.conf")
	assert.Equal(t, sandboxed, "")
	assert.Equal(t, original, after)
	assert.Equal(t, originalNetNS.Equal(sandboxedNetNS), true)