func TestInstanceAdmin(t *testing.T) {
client, server := test.AdminClient(instanceAdminResponse)
defer server.Close()
want :=
RestartResponse{
XMLName: xml.Name{Space: "http://marklogic.com/manage", Local: "restart"},
LastStartup: LastStartupElement{
XMLName: xml.Name{Space: "http://marklogic.com/manage", Local: "last-startup"},
Value: "2013-04-01T10:35:19.09913-07:00",
HostID: "13544732455686476949",
},
Link: LinkElement{
XMLName: xml.Name{Space: "http://marklogic.com/manage", Local: "link"},
KindRef: "timestamp",
URIRef: "/admin/v1/timestamp",
},
Message: "Check for new timestamp to verify host restart.",
}
// Using Basic Auth for test so initial call isn't actually made
respHandle := RestartResponseHandle{Format: handle.XML}
err := instanceAdmin(client, "admin", "password", "public", &respHandle)
resp := respHandle.Get()
if err != nil {
t.Errorf("Error = %v", err)
} else if resp == nil {
t.Errorf("No response found")
} else if !reflect.DeepEqual(want.LastStartup, resp.LastStartup) {
t.Errorf("InstanceAdmin LastStartup = %+v, Want = %+v", spew.Sdump(resp.LastStartup), spew.Sdump(want.LastStartup))
} else if !reflect.DeepEqual(resp.Link, want.Link) {
t.Errorf("InstanceAdmin Link = %+v, Want = %+v", spew.Sdump(resp.Link), spew.Sdump(want.Link))
} else if !reflect.DeepEqual(*resp, want) {
t.Errorf("InstanceAdmin Response = %+v, Want = %+v", spew.Sdump(*resp), spew.Sdump(want))
}
}
// testFetchTxBySha ensures FetchTxBySha conforms to the interface contract.
func testFetchTxBySha(tc *testContext) bool {
for i, tx := range tc.block.Transactions() {
txHash := tx.Sha()
txReplyList, err := tc.db.FetchTxBySha(txHash)
if err != nil {
tc.t.Errorf("FetchTxBySha (%s): block #%d (%s) "+
"tx #%d (%s) err: %v", tc.dbType, tc.blockHeight,
tc.blockHash, i, txHash, err)
return false
}
if len(txReplyList) == 0 {
tc.t.Errorf("FetchTxBySha (%s): block #%d (%s) "+
"tx #%d (%s) did not return reply data",
tc.dbType, tc.blockHeight, tc.blockHash, i,
txHash)
return false
}
txFromDb := txReplyList[len(txReplyList)-1].Tx
if !reflect.DeepEqual(tx.MsgTx(), txFromDb) {
tc.t.Errorf("FetchTxBySha (%s): block #%d (%s) "+
"tx #%d (%s) does not match stored tx\n"+
"got: %v\nwant: %v", tc.dbType, tc.blockHeight,
tc.blockHash, i, txHash, spew.Sdump(txFromDb),
spew.Sdump(tx.MsgTx()))
return false
}
}
return true
}
// Equal asserts that two objects are equal.
//
// assert.Equal(t, 123, 123, "123 and 123 should be equal")
//
// Returns whether the assertion was successful (true) or not (false).
func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
if !ObjectsAreEqual(expected, actual) {
var msg string
tp := reflect.TypeOf(expected)
k := tp.Kind()
if k == reflect.Ptr {
tp = tp.Elem()
k = tp.Kind()
}
if k == reflect.Struct || k == reflect.Map || k == reflect.Slice || k == reflect.Array {
msg = fmt.Sprintf("Not equal:\n"+
"---- Expected ----\n%s\n--------------\n"+
"---- Actual ------\n%s\n--------------",
spew.Sdump(expected),
spew.Sdump(actual))
} else {
msg = fmt.Sprintf("Not equal: %#v (expected)\n"+
" != %#v (actual)", expected, actual)
}
return Fail(t, msg, msgAndArgs...)
}
return true
}
func TestSphinxEncodeDecode(t *testing.T) {
// Create some test data with a randomly populated, yet valid onion
// forwarding message.
_, fwdMsg, err := newTestRoute(5)
if err != nil {
t.Fatalf("unable to create random onion packet: %v", err)
}
// Encode the created onion packet into an empty buffer. This should
// succeeed without any errors.
var b bytes.Buffer
if err := fwdMsg.Encode(&b); err != nil {
t.Fatalf("unable to encode message: %v", err)
}
// Now decode the bytes encoded above. Again, this should succeeed
// without any errors.
newFwdMsg := &OnionPacket{}
if err := newFwdMsg.Decode(&b); err != nil {
t.Fatalf("unable to decode message: %v", err)
}
// The two forwarding messages should now be identical.
if !reflect.DeepEqual(fwdMsg, newFwdMsg) {
t.Fatalf("forwarding messages don't match, %v vs %v",
spew.Sdump(fwdMsg), spew.Sdump(newFwdMsg))
}
}
// TestTestNet3GenesisBlock tests the genesis block of the test network (version
// 3) for validity by checking the encoded bytes and hashes.
func TestTestNet3GenesisBlock(t *testing.T) {
// Encode the genesis block to raw bytes.
var buf bytes.Buffer
err := btcnet.TestNet3Params.GenesisBlock.Serialize(&buf)
if err != nil {
t.Fatalf("TestTestNet3GenesisBlock: %v", err)
}
// Ensure the encoded block matches the expected bytes.
if !bytes.Equal(buf.Bytes(), testNet3GenesisBlockBytes) {
t.Fatalf("TestTestNet3GenesisBlock: Genesis block does not "+
"appear valid - got %v, want %v",
spew.Sdump(buf.Bytes()),
spew.Sdump(testNet3GenesisBlockBytes))
}
// Check hash of the block against expected hash.
hash, err := btcnet.TestNet3Params.GenesisBlock.BlockSha()
if err != nil {
t.Fatalf("BlockSha: %v", err)
}
if !btcnet.TestNet3Params.GenesisHash.IsEqual(&hash) {
t.Fatalf("TestTestNet3GenesisBlock: Genesis block hash does "+
"not appear valid - got %v, want %v", spew.Sdump(hash),
spew.Sdump(btcnet.TestNet3Params.GenesisHash))
}
}
func TestWatchNewFile(t *testing.T) {
t.Parallel()
dir, am := tmpManager(t, false)
defer os.RemoveAll(dir)
// Ensure the watcher is started before adding any files.
am.Accounts()
time.Sleep(200 * time.Millisecond)
// Move in the files.
wantAccounts := make([]Account, len(cachetestAccounts))
for i := range cachetestAccounts {
a := cachetestAccounts[i]
a.File = filepath.Join(dir, filepath.Base(a.File))
wantAccounts[i] = a
if err := cp.CopyFile(a.File, cachetestAccounts[i].File); err != nil {
t.Fatal(err)
}
}
// am should see the accounts.
var list []Account
for d := 200 * time.Millisecond; d < 5*time.Second; d *= 2 {
list = am.Accounts()
if reflect.DeepEqual(list, wantAccounts) {
return
}
time.Sleep(d)
}
t.Errorf("got %s, want %s", spew.Sdump(list), spew.Sdump(wantAccounts))
}
// diff returns a diff of both values as long as both are of the same type and
// are a struct, map, slice or array. Otherwise it returns an empty string.
func diff(expected interface{}, actual interface{}) string {
if expected == nil || actual == nil {
return ""
}
et, ek := typeAndKind(expected)
at, _ := typeAndKind(actual)
if et != at {
return ""
}
if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array {
return ""
}
e := spew.Sdump(expected)
a := spew.Sdump(actual)
diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
A: difflib.SplitLines(e),
B: difflib.SplitLines(a),
FromFile: "Expected",
FromDate: "",
ToFile: "Actual",
ToDate: "",
Context: 1,
})
return "\n\nDiff:\n" + diff
}
// Ensure a cursor with a single ref value can be converted into an iterator.
func TestFloatCursorIterator_SingleValue(t *testing.T) {
cur := NewCursor([]CursorItem{
{Key: 0, Value: float64(100)},
{Key: 3, Value: float64(200)},
}, true)
opt := influxql.IteratorOptions{
Expr: &influxql.VarRef{Val: "value"},
Ascending: true,
StartTime: influxql.MinTime,
EndTime: influxql.MaxTime,
}
itr := tsdb.NewFloatCursorIterator("series0", map[string]string{"host": "serverA"}, cur, opt)
defer itr.Close()
if p := itr.Next(); !deep.Equal(p, &influxql.FloatPoint{
Name: "series0",
Time: 0,
Value: float64(100),
}) {
t.Fatalf("unexpected point(0): %s", spew.Sdump(p))
}
if p := itr.Next(); !deep.Equal(p, &influxql.FloatPoint{
Name: "series0",
Time: 3,
Value: float64(200),
}) {
t.Fatalf("unexpected point(1): %s", spew.Sdump(p))
}
if p := itr.Next(); p != nil {
t.Fatalf("expected eof, got: %s", spew.Sdump(p))
}
}
// Ensure a cursor iterator does not go past the end time.
func TestFloatCursorIterator_EndTime(t *testing.T) {
cur := NewCursor([]CursorItem{
{Key: 0, Value: float64(100)},
{Key: 3, Value: float64(200)},
{Key: 4, Value: float64(300)},
}, true)
itr := tsdb.NewFloatCursorIterator("x", nil, cur, influxql.IteratorOptions{
Expr: &influxql.VarRef{Val: "value"},
Ascending: true,
EndTime: 3,
})
defer itr.Close()
// Verify that only two points are emitted.
if p := itr.Next(); p == nil || p.Time != 0 {
t.Fatalf("unexpected point(0): %s", spew.Sdump(p))
}
if p := itr.Next(); p == nil || p.Time != 3 {
t.Fatalf("unexpected point(1): %s", spew.Sdump(p))
}
if p := itr.Next(); p != nil {
t.Fatalf("expected eof, got: %s", spew.Sdump(p))
}
}
func TestAddChild(t *testing.T) {
parent := New()
children := []Node{
&Number{
Value: "1",
},
&Number{
Value: "2",
},
&Number{
Value: "3",
},
}
for _, child := range children {
parent.AddChild(child)
}
if gotChildren := parent.Children(); !reflect.DeepEqual(gotChildren, children) {
t.Fatalf(
"Expected: %s\n but got: %s",
spew.Sdump(children),
spew.Sdump(gotChildren),
)
}
for _, child := range children {
if gotParent := child.Parent(); !reflect.DeepEqual(gotParent, parent) {
t.Fatalf(
"Expected: %s\n but got: %s",
spew.Sdump(parent),
spew.Sdump(gotParent),
)
}
}
}
func (ctxt *snmpContext) processOutboundQueue() {
defer func() {
ctxt.outboundDied <- true
ctxt.conn.Close() // make sure that receive side shuts down too.
}()
ctxt.Debugf("Ctxt %s: outbound flow controller initializing", ctxt.name)
for {
select {
case msg := <-ctxt.outboundFlowControlQueue:
encodedMsg, err := msg.encode(ctxt.berEncoderFactory)
if err != nil {
ctxt.Debugf("Couldn't encode message: err: %s. Message:\n%s", err, spew.Sdump(msg))
continue
}
ctxt.Debugf("Ctxt %s: Sending message:\n%s", ctxt.name, spew.Sdump(msg))
if n, err := ctxt.conn.WriteToUDP(encodedMsg, msg.getAddress()); err != nil || n != len(encodedMsg) {
if strings.HasSuffix(err.Error(), "closed network connection") {
ctxt.Debugf("Ctxt %s: outbound flow controller shutting down due to closed connection", ctxt.name)
ctxt.incrementStat(StatType_OUTBOUND_CONNECTION_CLOSE)
} else {
ctxt.Errorf("Ctxt %s: UDP write failed, err: %s, numWritten: %d, expected: %d", ctxt.name, err, n, len(encodedMsg))
ctxt.incrementStat(StatType_OUTBOUND_CONNECTION_DEATH)
}
return
}
ctxt.incrementStat(StatType_OUTBOUND_MESSAGES_SENT)
case <-ctxt.outboundFlowControlShutdown:
ctxt.Debugf("Ctxt %s: outbound flow controller shutting down due to shutdown message", ctxt.name)
return
case <-ctxt.internalShutdownNotification:
ctxt.Debugf("Ctxt %s: outbound flow controller shutting down due to snmpContext shutdown", ctxt.name)
return
}
}
}
func TestEmit(t *testing.T) {
// Arrange
e := new(Emitter)
for i, c := range emitcases {
if isolateEmitCase >= 0 && isolateEmitCase != i {
continue
}
if testing.Verbose() {
fmt.Printf("testing emitter case %d...\n", i)
}
// Act
f, err := e.Emit("", c.src, nil)
// Assert
if (err != nil) != c.err {
if err == nil {
t.Errorf("[%d] - expected an error, got none", i)
} else {
t.Errorf("[%d] - expected no error, got `%s`", i, err)
}
}
if c.exp != nil {
if !equal(i, f, c.exp) {
t.Errorf("[%d] - expected\n", i)
t.Error(spew.Sdump(c.exp))
t.Error("got\n")
t.Error(spew.Sdump(f))
}
}
if !c.err && c.exp == nil {
t.Errorf("[%d] - no assertion", i)
}
}
}
func TestNone(t *testing.T) {
ctx := initTest()
if len(ctx.fd.running()) > 0 {
t.Errorf("fd.running = %s; want <empty>", spew.Sdump(ctx.fd.running()))
}
if len(ctx.execs) > 0 {
t.Errorf("exec = %s; want <empty>", spew.Sdump(ctx.execs))
}
ctx.conn.Transact(func(view db.Database) error {
m, _ := view.MinionSelf()
e := view.SelectFromEtcd(nil)[0]
m.PrivateIP = "1.2.3.4"
e.Leader = false
e.LeaderIP = "5.6.7.8"
view.Commit(m)
view.Commit(e)
return nil
})
ctx.run()
if len(ctx.fd.running()) > 0 {
t.Errorf("fd.running = %s; want <none>", spew.Sdump(ctx.fd.running()))
}
if len(ctx.execs) > 0 {
t.Errorf("exec = %s; want <empty>", spew.Sdump(ctx.execs))
}
}
// writeMessage sends a bitcoin Message to the peer with logging.
func (p *peer) writeMessage(msg btcwire.Message) {
// Don't do anything if we're disconnecting.
if atomic.LoadInt32(&p.disconnect) != 0 {
return
}
log.Debugf("[PEER] Sending command [%v] to %s", msg.Command(),
p.addr)
// Use closures to log expensive operations so they are only run when the
// logging level requires it.
log.Tracef("%v", newLogClosure(func() string {
return "[PEER] msg" + spew.Sdump(msg)
}))
log.Tracef("%v", newLogClosure(func() string {
var buf bytes.Buffer
err := btcwire.WriteMessage(&buf, msg, p.protocolVersion, p.btcnet)
if err != nil {
return err.Error()
}
return "[PEER] " + spew.Sdump(buf.Bytes())
}))
// Write the message to the peer.
err := btcwire.WriteMessage(p.conn, msg, p.protocolVersion, p.btcnet)
if err != nil {
p.Disconnect()
p.logError("[PEER] Can't send message: %v", err)
return
}
}
func checkJavascript(t *testing.T, code string, exp interface{}) {
resultKey := "result"
vm, err := newVM(ImportGetter{
Path: ".",
})
if err != nil {
t.Errorf(`Unexpected error: "%s".`, err.Error())
return
}
exec := fmt.Sprintf(`exports.%s = %s;`, resultKey, code)
moduleVal, err := runSpec(vm, "<test_code>", exec)
if err != nil {
t.Errorf(`Unexpected error: "%s".`, err.Error())
return
}
actualVal, err := moduleVal.Object().Get(resultKey)
if err != nil {
t.Errorf(`Unexpected error retrieving result from VM: "%s".`,
err.Error())
return
}
actual, _ := actualVal.Export()
if !reflect.DeepEqual(actual, exp) {
t.Errorf("Bad javascript code: Expected %s, got %s.",
spew.Sdump(exp), spew.Sdump(actual))
}
}
func testAppArmorNode() {
BeforeEach(func() {
By("Loading AppArmor profiles for testing")
framework.ExpectNoError(loadTestProfiles(), "Could not load AppArmor test profiles")
})
Context("when running with AppArmor", func() {
f := framework.NewDefaultFramework("apparmor-test")
It("should reject an unloaded profile", func() {
status := runAppArmorTest(f, "localhost/"+"non-existant-profile")
Expect(status.Phase).To(Equal(api.PodFailed), "PodStatus: %+v", status)
Expect(status.Reason).To(Equal("AppArmor"), "PodStatus: %+v", status)
})
It("should enforce a profile blocking writes", func() {
status := runAppArmorTest(f, "localhost/"+apparmorProfilePrefix+"deny-write")
if len(status.ContainerStatuses) == 0 {
framework.Failf("Unexpected pod status: %s", spew.Sdump(status))
return
}
state := status.ContainerStatuses[0].State.Terminated
Expect(state.ExitCode).To(Not(BeZero()), "ContainerStateTerminated: %+v", state)
})
It("should enforce a permissive profile", func() {
status := runAppArmorTest(f, "localhost/"+apparmorProfilePrefix+"audit-write")
if len(status.ContainerStatuses) == 0 {
framework.Failf("Unexpected pod status: %s", spew.Sdump(status))
return
}
state := status.ContainerStatuses[0].State.Terminated
Expect(state.ExitCode).To(BeZero(), "ContainerStateTerminated: %+v", state)
})
})
}
func TestCacheInitialReload(t *testing.T) {
cache := newAddrCache(cachetestDir)
accounts := cache.accounts()
if !reflect.DeepEqual(accounts, cachetestAccounts) {
t.Fatalf("got initial accounts: %swant %s", spew.Sdump(accounts), spew.Sdump(cachetestAccounts))
}
}
// readMessage reads the next bitcoin message from the peer with logging.
func (p *peer) readMessage() (msg btcwire.Message, buf []byte, err error) {
msg, buf, err = btcwire.ReadMessage(p.conn, p.protocolVersion, p.btcnet)
if err != nil {
return
}
// Use closures to log expensive operations so they are only run when
// the logging level requires it.
log.Debugf("%v", newLogClosure(func() string {
// Debug summary of message.
summary := messageSummary(msg)
if len(summary) > 0 {
summary = " (" + summary + ")"
}
return fmt.Sprintf("PEER: Received %v%s from %s",
msg.Command(), summary, p.addr)
}))
log.Tracef("%v", newLogClosure(func() string {
return "PEER: " + spew.Sdump(msg)
}))
log.Tracef("%v", newLogClosure(func() string {
return "PEER: " + spew.Sdump(buf)
}))
return
}
func testInterpolate(
t *testing.T, i *Interpolater,
scope *InterpolationScope,
n string, expectedVar ast.Variable) {
v, err := config.NewInterpolatedVariable(n)
if err != nil {
t.Fatalf("err: %s", err)
}
actual, err := i.Values(scope, map[string]config.InterpolatedVariable{
"foo": v,
})
if err != nil {
t.Fatalf("err: %s", err)
}
expected := map[string]ast.Variable{
"foo": expectedVar,
}
if !reflect.DeepEqual(actual, expected) {
spew.Config.DisableMethods = true
t.Fatalf("%q:\n\n actual: %#v\nexpected: %#v\n\n%s\n\n%s\n\n", n, actual, expected,
spew.Sdump(actual), spew.Sdump(expected))
}
}
func TestReadUpgradeStateV1toV2_outputs(t *testing.T) {
// ReadState should transparently detect the old version but will upgrade
// it on Write.
actual, err := ReadState(strings.NewReader(testV1StateWithOutputs))
if err != nil {
t.Fatalf("err: %s", err)
}
buf := new(bytes.Buffer)
if err := WriteState(actual, buf); err != nil {
t.Fatalf("err: %s", err)
}
if actual.Version != 2 {
t.Fatalf("bad: State version not incremented; is %d", actual.Version)
}
roundTripped, err := ReadState(buf)
if err != nil {
t.Fatalf("err: %s", err)
}
if !reflect.DeepEqual(actual, roundTripped) {
spew.Config.DisableMethods = true
t.Fatalf("bad:\n%s\n\nround tripped:\n%s\n", spew.Sdump(actual), spew.Sdump(roundTripped))
spew.Config.DisableMethods = false
}
}
// TestNewBlockFromBlockAndBytes tests creation of a Block from a MsgBlock and
// raw bytes.
func TestNewBlockFromBlockAndBytes(t *testing.T) {
// Serialize the test block.
var block100000Buf bytes.Buffer
err := Block100000.Serialize(&block100000Buf)
if err != nil {
t.Errorf("Serialize: %v", err)
}
block100000Bytes := block100000Buf.Bytes()
// Create a new block from the serialized bytes.
b := btcutil.NewBlockFromBlockAndBytes(&Block100000, block100000Bytes)
// Ensure we get the same data back out.
serializedBytes, err := b.Bytes()
if err != nil {
t.Errorf("Bytes: %v", err)
return
}
if !bytes.Equal(serializedBytes, block100000Bytes) {
t.Errorf("Bytes: wrong bytes - got %v, want %v",
spew.Sdump(serializedBytes),
spew.Sdump(block100000Bytes))
}
if msgBlock := b.MsgBlock(); !reflect.DeepEqual(msgBlock, &Block100000) {
t.Errorf("MsgBlock: mismatched MsgBlock - got %v, want %v",
spew.Sdump(msgBlock), spew.Sdump(&Block100000))
}
}
func TestBuildParameters(t *testing.T) {
want := "?uri=%2Ftest%2F1.json&uri=%2Ftest%2F2.json&category=metadata&" +
"category=content&collection=docs&perm:user=read&prop:date=2015-05-01&" +
"transform=my-transform&trans:param1=val1"
transform := &util.Transform{
Name: "my-transform",
Parameters: map[string]string{
"param1": "val1",
},
}
result := buildParameters(
[]string{"/test/1.json", "/test/2.json"},
[]string{"metadata", "content"},
[]string{"docs"},
map[string]string{
"user": "******",
},
map[string]string{
"date": "2015-05-01",
},
transform,
)
if want != result {
t.Errorf("Build Parameters Results = %+v, Want = %+v", spew.Sdump(result), spew.Sdump(want))
}
}
// TestGenesisBlock tests the genesis block of the main network for validity by
// checking the encoded bytes and hashes.
func TestGenesisBlock(t *testing.T) {
// Encode the genesis block to raw bytes.
var buf bytes.Buffer
err := btcwire.GenesisBlock.Serialize(&buf)
if err != nil {
t.Errorf("TestGenesisBlock: %v", err)
return
}
// Ensure the encoded block matches the expected bytes.
if !bytes.Equal(buf.Bytes(), genesisBlockBytes) {
t.Errorf("TestGenesisBlock: Genesis block does not appear valid - "+
"got %v, want %v", spew.Sdump(buf.Bytes()),
spew.Sdump(genesisBlockBytes))
return
}
// Check hash of the block against expected hash.
hash, err := btcwire.GenesisBlock.BlockSha()
if err != nil {
t.Errorf("BlockSha: %v", err)
}
if !btcwire.GenesisHash.IsEqual(&hash) {
t.Errorf("TestGenesisBlock: Genesis block hash does not appear valid - "+
"got %v, want %v", spew.Sdump(hash),
spew.Sdump(btcwire.GenesisHash))
return
}
}
func TestReduceDistinct(t *testing.T) {
v1 := distinctValues{
"2",
"1",
float64(2.0),
float64(1),
uint64(2),
uint64(1),
true,
false,
}
expect := distinctValues{
uint64(1),
float64(1),
uint64(2),
float64(2),
false,
true,
"1",
"2",
}
got := ReduceDistinct([]interface{}{v1, v1, expect})
if !reflect.DeepEqual(got, expect) {
t.Errorf("Wrong values. exp %v got %v", spew.Sdump(expect), spew.Sdump(got))
}
}
// TestTxSerialize tests MsgTx serialize and deserialize.
func TestTxSerialize(t *testing.T) {
noTx := btcwire.NewMsgTx()
noTx.Version = 1
noTxEncoded := []byte{
0x01, 0x00, 0x00, 0x00, // Version
0x00, // Varint for number of input transactions
0x00, // Varint for number of output transactions
0x00, 0x00, 0x00, 0x00, // Lock time
}
tests := []struct {
in *btcwire.MsgTx // Message to encode
out *btcwire.MsgTx // Expected decoded message
buf []byte // Serialized data
}{
// No transactions.
{
noTx,
noTx,
noTxEncoded,
},
// Multiple transactions.
{
multiTx,
multiTx,
multiTxEncoded,
},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Serialize the transaction.
var buf bytes.Buffer
err := test.in.Serialize(&buf)
if err != nil {
t.Errorf("Serialize #%d error %v", i, err)
continue
}
if !bytes.Equal(buf.Bytes(), test.buf) {
t.Errorf("Serialize #%d\n got: %s want: %s", i,
spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
continue
}
// Deserialize the transaction.
var tx btcwire.MsgTx
rbuf := bytes.NewReader(test.buf)
err = tx.Deserialize(rbuf)
if err != nil {
t.Errorf("Deserialize #%d error %v", i, err)
continue
}
if !reflect.DeepEqual(&tx, test.out) {
t.Errorf("Deserialize #%d\n got: %s want: %s", i,
spew.Sdump(&tx), spew.Sdump(test.out))
continue
}
}
}
func Test_distinctValues_Sort(t *testing.T) {
values := distinctValues{
"2",
"1",
float64(2.0),
float64(1),
uint64(2),
uint64(1),
true,
false,
}
expect := distinctValues{
uint64(1),
float64(1),
uint64(2),
float64(2),
false,
true,
"1",
"2",
}
sort.Sort(values)
if !reflect.DeepEqual(values, expect) {
t.Errorf("Wrong values. exp %v got %v", spew.Sdump(expect), spew.Sdump(values))
}
}
// TestTx tests the API for Tx.
func TestTx(t *testing.T) {
testTx := Block100000.Transactions[0]
tx := coinutil.NewTx(testTx)
// Ensure we get the same data back out.
if msgTx := tx.MsgTx(); !reflect.DeepEqual(msgTx, testTx) {
t.Errorf("MsgTx: mismatched MsgTx - got %v, want %v",
spew.Sdump(msgTx), spew.Sdump(testTx))
}
// Ensure transaction index set and get work properly.
wantIndex := 0
tx.SetIndex(0)
if gotIndex := tx.Index(); gotIndex != wantIndex {
t.Errorf("Index: mismatched index - got %v, want %v",
gotIndex, wantIndex)
}
// Hash for block 100,000 transaction 0.
wantShaStr := "8c14f0db3df150123e6f3dbbf30f8b955a8249b62ac1d1ff16284aefa3d06d87"
wantSha, err := wire.NewShaHashFromStr(wantShaStr)
if err != nil {
t.Errorf("NewShaHashFromStr: %v", err)
}
// Request the sha multiple times to test generation and caching.
for i := 0; i < 2; i++ {
sha := tx.Sha()
if !sha.IsEqual(wantSha) {
t.Errorf("Sha #%d mismatched sha - got %v, want %v", i,
sha, wantSha)
}
}
}
func TestReduceCountDistinct(t *testing.T) {
v1 := map[interface{}]struct{}{
"2": struct{}{},
"1": struct{}{},
float64(2.0): struct{}{},
float64(1): struct{}{},
uint64(2): struct{}{},
uint64(1): struct{}{},
true: struct{}{},
false: struct{}{},
}
v2 := map[interface{}]struct{}{
uint64(1): struct{}{},
float64(1): struct{}{},
uint64(2): struct{}{},
float64(2): struct{}{},
false: struct{}{},
true: struct{}{},
"1": struct{}{},
"2": struct{}{},
}
exp := 8
got := ReduceCountDistinct([]interface{}{v1, v1, v2})
if !reflect.DeepEqual(got, exp) {
t.Errorf("Wrong values. exp %v got %v", spew.Sdump(exp), spew.Sdump(got))
}
}
func runDialTest(t *testing.T, test dialtest) {
var (
vtime time.Time
running int
)
pm := func(ps []*Peer) map[discover.NodeID]*Peer {
m := make(map[discover.NodeID]*Peer)
for _, p := range ps {
m[p.rw.id] = p
}
return m
}
for i, round := range test.rounds {
for _, task := range round.done {
running--
if running < 0 {
panic("running task counter underflow")
}
test.init.taskDone(task, vtime)
}
new := test.init.newTasks(running, pm(round.peers), vtime)
if !sametasks(new, round.new) {
t.Errorf("round %d: new tasks mismatch:\ngot %v\nwant %v\nstate: %v\nrunning: %v\n",
i, spew.Sdump(new), spew.Sdump(round.new), spew.Sdump(test.init), spew.Sdump(running))
}
// Time advances by 16 seconds on every round.
vtime = vtime.Add(16 * time.Second)
running += len(new)
}
}
// Execute will execute all script in the script engine and return either nil
// for successful validation or an error if one occurred.
func (s *Script) Execute() (err error) {
done := false
for done != true {
log.Tracef("%v", newLogClosure(func() string {
dis, err := s.DisasmPC()
if err != nil {
return fmt.Sprintf("stepping (%v)", err)
}
return fmt.Sprintf("stepping %v", dis)
}))
done, err = s.Step()
if err != nil {
return err
}
log.Tracef("%v", newLogClosure(func() string {
var dstr, astr string
// if we're tracing, dump the stacks.
if s.dstack.Depth() != 0 {
dstr = "Stack\n" + spew.Sdump(s.dstack)
}
if s.astack.Depth() != 0 {
astr = "AltStack\n" + spew.Sdump(s.astack)
}
return dstr + astr
}))
}
return s.CheckErrorCondition()
}