Skip to main content

Write Test Files

To test your application, add the test files to your code.

After you add the test files, change into the interchange directory with your terminal, then run:

go test -timeout 30s ./x/dex/types

Order Book Tests

Create a new x/dex/types/order_book_test.go file in the types directory.

Add the following testsuite:

// x/dex/types/order_book_test.go

package types_test

import (
"math/rand"
"testing"

"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/require"

"interchange/x/dex/types"
)

func GenString(n int) string {
alpha := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

buf := make([]rune, n)
for i := range buf {
buf[i] = alpha[rand.Intn(len(alpha))]
}

return string(buf)
}

func GenAddress() string {
pk := ed25519.GenPrivKey().PubKey()
addr := pk.Address()
return sdk.AccAddress(addr).String()
}

func GenAmount() int32 {
return int32(rand.Intn(int(types.MaxAmount)) + 1)
}

func GenPrice() int32 {
return int32(rand.Intn(int(types.MaxPrice)) + 1)
}

func GenPair() (string, string) {
return GenString(10), GenString(10)
}

func GenOrder() (string, int32, int32) {
return GenLocalAccount(), GenAmount(), GenPrice()
}

func GenLocalAccount() string {
return GenAddress()
}

func MockAccount(str string) string {
return str
}

func OrderListToOrderBook(list []types.Order) types.OrderBook {
listCopy := make([]*types.Order, len(list))
for i, order := range list {
order := order
listCopy[i] = &order
}

return types.OrderBook{
IdCount: 0,
Orders: listCopy,
}
}

func TestRemoveOrderFromID(t *testing.T) {
inputList := []types.Order{
{Id: 3, Creator: MockAccount("3"), Amount: 2, Price: 10},
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
}

book := OrderListToOrderBook(inputList)
expectedList := []types.Order{
{Id: 3, Creator: MockAccount("3"), Amount: 2, Price: 10},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
}
expectedBook := OrderListToOrderBook(expectedList)
err := book.RemoveOrderFromID(2)
require.NoError(t, err)
require.Equal(t, expectedBook, book)

book = OrderListToOrderBook(inputList)
expectedList = []types.Order{
{Id: 3, Creator: MockAccount("3"), Amount: 2, Price: 10},
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
}
expectedBook = OrderListToOrderBook(expectedList)
err = book.RemoveOrderFromID(0)
require.NoError(t, err)
require.Equal(t, expectedBook, book)

book = OrderListToOrderBook(inputList)
expectedList = []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
}
expectedBook = OrderListToOrderBook(expectedList)
err = book.RemoveOrderFromID(3)
require.NoError(t, err)
require.Equal(t, expectedBook, book)

book = OrderListToOrderBook(inputList)
err = book.RemoveOrderFromID(4)
require.ErrorIs(t, err, types.ErrOrderNotFound)
}

Buy Order Tests

Create a new x/dex/types/buy_order_book_test.go file in the types directory to add the tests for the Buy Order Book:

// x/dex/types/buy_order_book_test.go

package types_test

import (
"sort"
"testing"

"github.com/stretchr/testify/require"

"interchange/x/dex/types"
)

func OrderListToBuyOrderBook(list []types.Order) types.BuyOrderBook {
listCopy := make([]*types.Order, len(list))
for i, order := range list {
order := order
listCopy[i] = &order
}

book := types.BuyOrderBook{
AmountDenom: "foo",
PriceDenom: "bar",
Book: &types.OrderBook{
IdCount: 0,
Orders: listCopy,
},
}
return book
}

func TestAppendOrder(t *testing.T) {
buyBook := types.NewBuyOrderBook(GenPair())

// Prevent zero amount
seller, amount, price := GenOrder()
_, err := buyBook.AppendOrder(seller, 0, price)
require.ErrorIs(t, err, types.ErrZeroAmount)

// Prevent big amount
_, err = buyBook.AppendOrder(seller, types.MaxAmount+1, price)
require.ErrorIs(t, err, types.ErrMaxAmount)

// Prevent zero price
_, err = buyBook.AppendOrder(seller, amount, 0)
require.ErrorIs(t, err, types.ErrZeroPrice)

// Prevent big price
_, err = buyBook.AppendOrder(seller, amount, types.MaxPrice+1)
require.ErrorIs(t, err, types.ErrMaxPrice)

// Can append buy orders
for i := 0; i < 20; i++ {
// Append a new order
creator, amount, price := GenOrder()
newOrder := types.Order{
Id: buyBook.Book.IdCount,
Creator: creator,
Amount: amount,
Price: price,
}
orderID, err := buyBook.AppendOrder(creator, amount, price)

// Checks
require.NoError(t, err)
require.Contains(t, buyBook.Book.Orders, &newOrder)
require.Equal(t, newOrder.Id, orderID)
}

require.Len(t, buyBook.Book.Orders, 20)
require.True(t, sort.SliceIsSorted(buyBook.Book.Orders, func(i, j int) bool {
return buyBook.Book.Orders[i].Price < buyBook.Book.Orders[j].Price
}))
}

type liquidateSellRes struct {
Book []types.Order
Remaining types.Order
Liquidated types.Order
Gain int32
Match bool
Filled bool
}

func simulateLiquidateFromSellOrder(
t *testing.T,
inputList []types.Order,
inputOrder types.Order,
expected liquidateSellRes,
) {
book := OrderListToBuyOrderBook(inputList)
expectedBook := OrderListToBuyOrderBook(expected.Book)

require.True(t, sort.SliceIsSorted(book.Book.Orders, func(i, j int) bool {
return book.Book.Orders[i].Price < book.Book.Orders[j].Price
}))
require.True(t, sort.SliceIsSorted(expectedBook.Book.Orders, func(i, j int) bool {
return expectedBook.Book.Orders[i].Price < expectedBook.Book.Orders[j].Price
}))

remaining, liquidated, gain, match, filled := book.LiquidateFromSellOrder(inputOrder)

require.Equal(t, expectedBook, book)
require.Equal(t, expected.Remaining, remaining)
require.Equal(t, expected.Liquidated, liquidated)
require.Equal(t, expected.Gain, gain)
require.Equal(t, expected.Match, match)
require.Equal(t, expected.Filled, filled)
}

func TestLiquidateFromSellOrder(t *testing.T) {
// No match for empty book
inputOrder := types.Order{Id: 10, Creator: MockAccount("1"), Amount: 100, Price: 30}
book := OrderListToBuyOrderBook([]types.Order{})
_, _, _, match, _ := book.LiquidateFromSellOrder(inputOrder)
require.False(t, match)

// Buy book
inputBook := []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
}

// Test no match if highest bid too low (25 < 30)
book = OrderListToBuyOrderBook(inputBook)
_, _, _, match, _ = book.LiquidateFromSellOrder(inputOrder)
require.False(t, match)

// Entirely filled (30 < 50)
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 30, Price: 22}
expected := liquidateSellRes{
Book: []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 0, Creator: MockAccount("0"), Amount: 20, Price: 25},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 0, Price: 22},
Liquidated: types.Order{Id: 0, Creator: MockAccount("0"), Amount: 30, Price: 25},
Gain: int32(30 * 25),
Match: true,
Filled: true,
}
simulateLiquidateFromSellOrder(t, inputBook, inputOrder, expected)

// Entirely filled and liquidated ( 50 = 50)
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 50, Price: 15}
expected = liquidateSellRes{
Book: []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 0, Price: 15},
Liquidated: types.Order{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
Gain: int32(50 * 25),
Match: true,
Filled: true,
}
simulateLiquidateFromSellOrder(t, inputBook, inputOrder, expected)

// Not filled and entirely liquidated (60 > 50)
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 60, Price: 10}
expected = liquidateSellRes{
Book: []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 10, Price: 10},
Liquidated: types.Order{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
Gain: int32(50 * 25),
Match: true,
Filled: false,
}
simulateLiquidateFromSellOrder(t, inputBook, inputOrder, expected)
}

type fillSellRes struct {
Book []types.Order
Remaining types.Order
Liquidated []types.Order
Gain int32
Filled bool
}

func simulateFillSellOrder(
t *testing.T,
inputList []types.Order,
inputOrder types.Order,
expected fillSellRes,
) {
book := OrderListToBuyOrderBook(inputList)
expectedBook := OrderListToBuyOrderBook(expected.Book)

require.True(t, sort.SliceIsSorted(book.Book.Orders, func(i, j int) bool {
return book.Book.Orders[i].Price < book.Book.Orders[j].Price
}))
require.True(t, sort.SliceIsSorted(expectedBook.Book.Orders, func(i, j int) bool {
return expectedBook.Book.Orders[i].Price < expectedBook.Book.Orders[j].Price
}))

remaining, liquidated, gain, filled := book.FillSellOrder(inputOrder)

require.Equal(t, expectedBook, book)
require.Equal(t, expected.Remaining, remaining)
require.Equal(t, expected.Liquidated, liquidated)
require.Equal(t, expected.Gain, gain)
require.Equal(t, expected.Filled, filled)
}

func TestFillSellOrder(t *testing.T) {
var inputBook []types.Order

// Empty book
inputOrder := types.Order{Id: 10, Creator: MockAccount("1"), Amount: 30, Price: 30}
expected := fillSellRes{
Book: []types.Order{},
Remaining: inputOrder,
Liquidated: []types.Order(nil),
Gain: int32(0),
Filled: false,
}
simulateFillSellOrder(t, inputBook, inputOrder, expected)

// No match
inputBook = []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
}
expected = fillSellRes{
Book: inputBook,
Remaining: inputOrder,
Liquidated: []types.Order(nil),
Gain: int32(0),
Filled: false,
}
simulateFillSellOrder(t, inputBook, inputOrder, expected)

// First order liquidated, not filled
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 60, Price: 22}
expected = fillSellRes{
Book: []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 10, Price: 22},
Liquidated: []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
},
Gain: int32(50 * 25),
Filled: false,
}
simulateFillSellOrder(t, inputBook, inputOrder, expected)

// Filled with two order
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 60, Price: 18}
expected = fillSellRes{
Book: []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 190, Price: 20},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 0, Price: 18},
Liquidated: []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 10, Price: 20},
},
Gain: int32(50*25 + 10*20),
Filled: true,
}
simulateFillSellOrder(t, inputBook, inputOrder, expected)

// Not filled, buy order book liquidated
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 300, Price: 10}
expected = fillSellRes{
Book: []types.Order{},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 20, Price: 10},
Liquidated: []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
},
Gain: int32(50*25 + 200*20 + 30*15),
Filled: false,
}
simulateFillSellOrder(t, inputBook, inputOrder, expected)
}

Sell Order Tests

Create a new testsuite for Sell Orders in a new file x/dex/types/sell_order_book_test.go:

// x/dex/types/sell_order_book_test.go

package types_test

import (
"sort"
"testing"

"github.com/stretchr/testify/require"

"interchange/x/dex/types"
)

func OrderListToSellOrderBook(list []types.Order) types.SellOrderBook {
listCopy := make([]*types.Order, len(list))
for i, order := range list {
order := order
listCopy[i] = &order
}

book := types.SellOrderBook{
AmountDenom: "foo",
PriceDenom: "bar",
Book: &types.OrderBook{
IdCount: 0,
Orders: listCopy,
},
}
return book
}

func TestSellOrderBook_AppendOrder(t *testing.T) {
sellBook := types.NewSellOrderBook(GenPair())

// Prevent zero amount
seller, amount, price := GenOrder()
_, err := sellBook.AppendOrder(seller, 0, price)
require.ErrorIs(t, err, types.ErrZeroAmount)

// Prevent big amount
_, err = sellBook.AppendOrder(seller, types.MaxAmount+1, price)
require.ErrorIs(t, err, types.ErrMaxAmount)

// Prevent zero price
_, err = sellBook.AppendOrder(seller, amount, 0)
require.ErrorIs(t, err, types.ErrZeroPrice)

// Prevent big price
_, err = sellBook.AppendOrder(seller, amount, types.MaxPrice+1)
require.ErrorIs(t, err, types.ErrMaxPrice)

// Can append sell orders
for i := 0; i < 20; i++ {
// Append a new order
creator, amount, price := GenOrder()
newOrder := types.Order{
Id: sellBook.Book.IdCount,
Creator: creator,
Amount: amount,
Price: price,
}
orderID, err := sellBook.AppendOrder(creator, amount, price)

// Checks
require.NoError(t, err)
require.Contains(t, sellBook.Book.Orders, &newOrder)
require.Equal(t, newOrder.Id, orderID)
}
require.Len(t, sellBook.Book.Orders, 20)
require.True(t, sort.SliceIsSorted(sellBook.Book.Orders, func(i, j int) bool {
return sellBook.Book.Orders[i].Price > sellBook.Book.Orders[j].Price
}))
}

type liquidateBuyRes struct {
Book []types.Order
Remaining types.Order
Liquidated types.Order
Purchase int32
Match bool
Filled bool
}

func simulateLiquidateFromBuyOrder(
t *testing.T,
inputList []types.Order,
inputOrder types.Order,
expected liquidateBuyRes,
) {
book := OrderListToSellOrderBook(inputList)
expectedBook := OrderListToSellOrderBook(expected.Book)
require.True(t, sort.SliceIsSorted(book.Book.Orders, func(i, j int) bool {
return book.Book.Orders[i].Price > book.Book.Orders[j].Price
}))
require.True(t, sort.SliceIsSorted(expectedBook.Book.Orders, func(i, j int) bool {
return expectedBook.Book.Orders[i].Price > expectedBook.Book.Orders[j].Price
}))

remaining, liquidated, purchase, match, filled := book.LiquidateFromBuyOrder(inputOrder)

require.Equal(t, expectedBook, book)
require.Equal(t, expected.Remaining, remaining)
require.Equal(t, expected.Liquidated, liquidated)
require.Equal(t, expected.Purchase, purchase)
require.Equal(t, expected.Match, match)
require.Equal(t, expected.Filled, filled)
}

func TestLiquidateFromBuyOrder(t *testing.T) {
// No match for empty book
inputOrder := types.Order{Id: 10, Creator: MockAccount("1"), Amount: 100, Price: 10}
book := OrderListToSellOrderBook([]types.Order{})
_, _, _, match, _ := book.LiquidateFromBuyOrder(inputOrder)
require.False(t, match)

// Sell book
inputBook := []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
}

// Test no match if lowest ask too high (25 < 30)
book = OrderListToSellOrderBook(inputBook)
_, _, _, match, _ = book.LiquidateFromBuyOrder(inputOrder)
require.False(t, match)

// Entirely filled (30 > 15)
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 20, Price: 30}
expected := liquidateBuyRes{
Book: []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 2, Creator: MockAccount("2"), Amount: 10, Price: 15},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 0, Price: 30},
Liquidated: types.Order{Id: 2, Creator: MockAccount("2"), Amount: 20, Price: 15},
Purchase: int32(20),
Match: true,
Filled: true,
}
simulateLiquidateFromBuyOrder(t, inputBook, inputOrder, expected)

// Entirely filled (30 = 30)
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 30, Price: 30}
expected = liquidateBuyRes{
Book: []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 0, Price: 30},
Liquidated: types.Order{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
Purchase: int32(30),
Match: true,
Filled: true,
}
simulateLiquidateFromBuyOrder(t, inputBook, inputOrder, expected)

// Not filled and entirely liquidated (60 > 30)
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 60, Price: 30}
expected = liquidateBuyRes{
Book: []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 30, Price: 30},
Liquidated: types.Order{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
Purchase: int32(30),
Match: true,
Filled: false,
}
simulateLiquidateFromBuyOrder(t, inputBook, inputOrder, expected)
}

type fillBuyRes struct {
Book []types.Order
Remaining types.Order
Liquidated []types.Order
Purchase int32
Filled bool
}

func simulateFillBuyOrder(
t *testing.T,
inputList []types.Order,
inputOrder types.Order,
expected fillBuyRes,
) {
book := OrderListToSellOrderBook(inputList)
expectedBook := OrderListToSellOrderBook(expected.Book)

require.True(t, sort.SliceIsSorted(book.Book.Orders, func(i, j int) bool {
return book.Book.Orders[i].Price > book.Book.Orders[j].Price
}))
require.True(t, sort.SliceIsSorted(expectedBook.Book.Orders, func(i, j int) bool {
return expectedBook.Book.Orders[i].Price > expectedBook.Book.Orders[j].Price
}))

remaining, liquidated, purchase, filled := book.FillBuyOrder(inputOrder)

require.Equal(t, expectedBook, book)
require.Equal(t, expected.Remaining, remaining)
require.Equal(t, expected.Liquidated, liquidated)
require.Equal(t, expected.Purchase, purchase)
require.Equal(t, expected.Filled, filled)
}

func TestFillBuyOrder(t *testing.T) {
var inputBook []types.Order

// Empty book
inputOrder := types.Order{Id: 10, Creator: MockAccount("1"), Amount: 30, Price: 10}
expected := fillBuyRes{
Book: []types.Order{},
Remaining: inputOrder,
Liquidated: []types.Order(nil),
Purchase: int32(0),
Filled: false,
}
simulateFillBuyOrder(t, inputBook, inputOrder, expected)

// No match
inputBook = []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
}
expected = fillBuyRes{
Book: inputBook,
Remaining: inputOrder,
Liquidated: []types.Order(nil),
Purchase: int32(0),
Filled: false,
}
simulateFillBuyOrder(t, inputBook, inputOrder, expected)

// First order liquidated, not filled
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 60, Price: 18}
expected = fillBuyRes{
Book: []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 30, Price: 18},
Liquidated: []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
},
Purchase: int32(30),
Filled: false,
}
simulateFillBuyOrder(t, inputBook, inputOrder, expected)

// Filled with two order
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 60, Price: 22}
expected = fillBuyRes{
Book: []types.Order{
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
{Id: 1, Creator: MockAccount("1"), Amount: 170, Price: 20},
},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 0, Price: 22},
Liquidated: []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 30, Price: 20},
},
Purchase: int32(30 + 30),
Filled: true,
}
simulateFillBuyOrder(t, inputBook, inputOrder, expected)

// Not filled, sell order book liquidated
inputOrder = types.Order{Id: 10, Creator: MockAccount("1"), Amount: 300, Price: 30}
expected = fillBuyRes{
Book: []types.Order{},
Remaining: types.Order{Id: 10, Creator: MockAccount("1"), Amount: 20, Price: 30},
Liquidated: []types.Order{
{Id: 2, Creator: MockAccount("2"), Amount: 30, Price: 15},
{Id: 1, Creator: MockAccount("1"), Amount: 200, Price: 20},
{Id: 0, Creator: MockAccount("0"), Amount: 50, Price: 25},
},
Purchase: int32(30 + 200 + 50),
Filled: false,
}
simulateFillBuyOrder(t, inputBook, inputOrder, expected)
}

Successful Test Output

When the tests are successful, your output is:

ok      interchange/x/dex/types       0.550s