Skip to main content
Version: v0.25

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