package difficulty

import (
	"math/big"
	"reflect"
	"strconv"
	"testing"

	"github.com/vapor/consensus"
	"github.com/vapor/protocol/bc"
	"github.com/vapor/protocol/bc/types"
)

// A lower difficulty Int actually reflects a more difficult mining progress.
func TestCalcNextRequiredDifficulty(t *testing.T) {
	targetTimeSpan := uint64(consensus.BlocksPerRetarget * consensus.TargetSecondsPerBlock)
	cases := []struct {
		lastBH    *types.BlockHeader
		compareBH *types.BlockHeader
		want      uint64
	}{
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
			},
			BigToCompact(big.NewInt(1000)),
		},
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan * 2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
			},
			BigToCompact(big.NewInt(2000)),
		},
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan*2 - consensus.TargetSecondsPerBlock,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
			},
			BigToCompact(big.NewInt(1000)),
		},
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan / 2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
			},
			BigToCompact(big.NewInt(500)),
		},
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget * 2,
				Timestamp: targetTimeSpan + targetTimeSpan*2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(2000)),
		},
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget * 2,
				Timestamp: targetTimeSpan + targetTimeSpan/2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(500)),
		},
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget*2 - 1,
				Timestamp: targetTimeSpan + targetTimeSpan*2 - consensus.TargetSecondsPerBlock,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(1000)),
		},
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget*2 - 1,
				Timestamp: targetTimeSpan + targetTimeSpan/2 - consensus.TargetSecondsPerBlock,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(1000)),
		},
		// lastBH.Height: 0, lastBH.Timestamp - compareBH.Timestamp: 0, lastBH.Bits: 0
		{
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
				Bits:      0,
			},
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
			},
			0,
		},
		// lastBH.Height: 0, lastBH.Timestamp - compareBH.Timestamp: 0, lastBH.Bits: 18446744073709551615
		{
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
				Bits:      18446744073709551615,
			},
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
			},
			18446744073709551615,
		},
		// lastBH.Height: 0, lastBH.Timestamp - compareBH.Timestamp: 0, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    0,
				Timestamp: 0,
			},
			BigToCompact(big.NewInt(1000)),
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: 0, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan,
			},
			0,
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: -9223372036854775808, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan + 9223372036854775808,
			},
			540431955291560988,
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: 9223372036854775807, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan + 9223372036854775807,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan,
			},
			504403158272597019,
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: 18446744073709551615, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: 18446744073709551615,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: 0,
			},
			108086391056957440,
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: 302400, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan * 2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(1000)),
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: 604800, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan * 3,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan,
			},
			144115188076367872,
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: 151200, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan + 9223372036854775807,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan,
			},
			504403158272597019,
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: 302400, lastBH.Bits: 0
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan * 2,
				Bits:      0,
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan,
			},
			0,
		},
		// lastBH.Height: consensus.BlocksPerRetarget, lastBH.Timestamp - compareBH.Timestamp: 302400, lastBH.Bits: 18446744073709551615
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan * 2,
				Bits:      18446744073709551615,
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan,
			},
			252201579141136384,
		},
		// lastBH.Height: consensus.BlocksPerRetarget + 1, lastBH.Timestamp - compareBH.Timestamp: 302400, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget + 1,
				Timestamp: targetTimeSpan * 2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(1000)),
		},
		// lastBH.Height: consensus.BlocksPerRetarget - 1, lastBH.Timestamp - compareBH.Timestamp: 302400, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 1,
				Timestamp: targetTimeSpan * 2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget - 2,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(1000)),
		},
		// lastBH.Height: consensus.BlocksPerRetarget * 2, lastBH.Timestamp - compareBH.Timestamp: 302400, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget * 2,
				Timestamp: targetTimeSpan * 2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget*2 - 1,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(1000)),
		},
		// lastBH.Height: consensus.BlocksPerRetarget / 2, lastBH.Timestamp - compareBH.Timestamp: 302400, lastBH.Bits: bigInt(1000)
		{
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget / 2,
				Timestamp: targetTimeSpan * 2,
				Bits:      BigToCompact(big.NewInt(1000)),
			},
			&types.BlockHeader{
				Height:    consensus.BlocksPerRetarget/2 - 1,
				Timestamp: targetTimeSpan,
			},
			BigToCompact(big.NewInt(1000)),
		},
	}

	for i, c := range cases {
		if got := CalcNextRequiredDifficulty(c.lastBH, c.compareBH); got != c.want {
			t.Errorf("Compile(%d) = %d want %d\n", i, got, c.want)
			return
		}
	}
}

func TestHashToBig(t *testing.T) {
	cases := []struct {
		in  [32]byte
		out [32]byte
	}{
		{
			in: [32]byte{
				0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
				0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
				0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
				0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
			},
			out: [32]byte{
				0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
				0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
				0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
				0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
			},
		},
		{
			in: [32]byte{
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
				0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
			},
			out: [32]byte{
				0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
				0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			},
		},
		{
			in: [32]byte{
				0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
				0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
				0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
				0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
			},
			out: [32]byte{
				0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
				0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
				0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
				0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
			},
		},
	}

	for i, c := range cases {
		bhash := bc.NewHash(c.in)
		result := HashToBig(&bhash).Bytes()

		var resArr [32]byte
		copy(resArr[:], result)

		if !reflect.DeepEqual(resArr, c.out) {
			t.Errorf("TestHashToBig test #%d failed:\n\tgot\t%x\n\twant\t%x\n", i, resArr, c.out)
			return
		}
	}
}

func TestCompactToBig(t *testing.T) {
	cases := []struct {
		in  string
		out *big.Int
	}{
		{
			in: `00000000` + //Exponent
				`0` + //Sign
				`0000000000000000000000000000000000000000000000000000000`, //Mantissa
			out: big.NewInt(0),
		},
		{
			in: `00000000` + //Exponent
				`1` + //Sign
				`0000000000000000000000000000000000000000000000000000000`, //Mantissa
			out: big.NewInt(0),
		},
		{
			in: `00000001` + //Exponent
				`0` + //Sign
				`0000000000000000000000000000000000000010000000000000000`, //Mantissa
			out: big.NewInt(1),
		},
		{
			in: `00000001` + //Exponent
				`1` + //Sign
				`0000000000000000000000000000000000000010000000000000000`, //Mantissa
			out: big.NewInt(-1),
		},
		{
			in: `00000011` + //Exponent
				`0` + //Sign
				`0000000000000000000000000000000000000010000000000000000`, //Mantissa
			out: big.NewInt(65536),
		},
		{
			in: `00000011` + //Exponent
				`1` + //Sign
				`0000000000000000000000000000000000000010000000000000000`, //Mantissa
			out: big.NewInt(-65536),
		},
		{
			in: `00000100` + //Exponent
				`0` + //Sign
				`0000000000000000000000000000000000000010000000000000000`, //Mantissa
			out: big.NewInt(16777216),
		},
		{
			in: `00000100` + //Exponent
				`1` + //Sign
				`0000000000000000000000000000000000000010000000000000000`, //Mantissa
			out: big.NewInt(-16777216),
		},
		{
			//btm PowMin test
			// PowMinBits = 2161727821138738707, i.e 0x1e000000000dbe13, as defined
			// in /consensus/general.go
			in: `00011110` + //Exponent
				`0` + //Sign
				`0000000000000000000000000000000000011011011111000010011`, //Mantissa
			out: big.NewInt(0).Lsh(big.NewInt(0x0dbe13), 27*8), //2161727821138738707
		},
	}

	for i, c := range cases {
		compact, _ := strconv.ParseUint(c.in, 2, 64)
		r := CompactToBig(compact)
		if r.Cmp(c.out) != 0 {
			t.Error("TestCompactToBig test #", i, "failed: got", r, "want", c.out)
			return
		}
	}
}

func TestBigToCompact(t *testing.T) {
	// basic tests
	tests := []struct {
		in  int64
		out uint64
	}{
		{0, 0x0000000000000000},
		{-0, 0x0000000000000000},
		{1, 0x0100000000010000},
		{-1, 0x0180000000010000},
		{65536, 0x0300000000010000},
		{-65536, 0x0380000000010000},
		{16777216, 0x0400000000010000},
		{-16777216, 0x0480000000010000},
	}

	for x, test := range tests {
		n := big.NewInt(test.in)
		r := BigToCompact(n)
		if r != test.out {
			t.Errorf("TestBigToCompact test #%d failed: got 0x%016x want 0x%016x\n",
				x, r, test.out)
			return
		}
	}

	// btm PowMin test
	// PowMinBits = 2161727821138738707, i.e 0x1e000000000dbe13, as defined
	// in /consensus/general.go
	n := big.NewInt(0).Lsh(big.NewInt(0x0dbe13), 27*8)
	out := uint64(0x1e000000000dbe13)
	r := BigToCompact(n)
	if r != out {
		t.Errorf("TestBigToCompact test #%d failed: got 0x%016x want 0x%016x\n",
			len(tests), r, out)
		return
	}
}

func TestCalcWorkWithIntStr(t *testing.T) {
	cases := []struct {
		strBits string
		want    *big.Int
	}{
		// Exponent: 0, Sign: 0, Mantissa: 0
		{
			`00000000` + //Exponent
				`0` + //Sign
				`0000000000000000000000000000000000000000000000000000000`, //Mantissa
			big.NewInt(0),
		},
		// Exponent: 0, Sign: 0, Mantissa: 1 (difficultyNum = 0 and difficultyNum.Sign() = 0)
		{
			`00000000` +
				`0` +
				`0000000000000000000000000000000000000000000000000000001`,
			big.NewInt(0),
		},
		// Exponent: 0, Sign: 0, Mantissa: 65536 (difficultyNum = 0 and difficultyNum.Sign() = 0)
		{
			`00000000` +
				`0` +
				`0000000000000000000000000000000000000010000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 0, Sign: 0, Mantissa: 16777216 (difficultyNum = 1 and difficultyNum.Sign() = 1)
		{
			`00000000` +
				`0` +
				`0000000000000000000000000000001000000000000000000000000`,
			new(big.Int).Div(oneLsh256, big.NewInt(2)),
		},
		// Exponent: 0, Sign: 0, Mantissa: 0x007fffffffffffff
		{
			`00000000` +
				`0` +
				`1111111111111111111111111111111111111111111111111111111`,
			big.NewInt(0).Lsh(big.NewInt(0x020000), 208),
		},
		// Exponent: 0, Sign: 1, Mantissa: 0
		{
			`00000000` +
				`1` +
				`0000000000000000000000000000000000000000000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 0, Sign: 1, Mantissa: 1 (difficultyNum = 0 and difficultyNum.Sign() = 0)
		{
			`00000000` +
				`1` +
				`0000000000000000000000000000000000000000000000000000001`,
			big.NewInt(0),
		},
		// Exponent: 0, Sign: 1, Mantissa: 65536 (difficultyNum = 0 and difficultyNum.Sign() = 0)
		{
			`00000000` +
				`1` +
				`0000000000000000000000000000000000000010000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 0, Sign: 0, Mantissa: 16777216 (difficultyNum = -1 and difficultyNum.Sign() = -1)
		{
			`00000000` +
				`1` +
				`0000000000000000000000000000001000000000000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 0, Sign: 1, Mantissa: 0x007fffffffffffff
		{
			`00000000` +
				`1` +
				`1111111111111111111111111111111111111111111111111111111`,
			big.NewInt(0),
		},
		// Exponent: 3, Sign: 0, Mantissa: 0
		{
			`00000011` +
				`0` +
				`0000000000000000000000000000000000000000000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 3, Sign: 0, Mantissa: 1 (difficultyNum = 1 and difficultyNum.Sign() = 1)
		{
			`00000011` +
				`0` +
				`0000000000000000000000000000000000000000000000000000001`,
			new(big.Int).Div(oneLsh256, big.NewInt(2)),
		},
		// Exponent: 3, Sign: 0, Mantissa: 65536 (difficultyNum = 65536 and difficultyNum.Sign() = 1)
		{
			`00000011` +
				`0` +
				`0000000000000000000000000000000000000010000000000000000`,
			new(big.Int).Div(oneLsh256, big.NewInt(65537)),
		},
		// Exponent: 0, Sign: 0, Mantissa: 16777216 (difficultyNum = 16777216 and difficultyNum.Sign() = 1)
		{
			`00000011` +
				`0` +
				`0000000000000000000000000000001000000000000000000000000`,
			new(big.Int).Div(oneLsh256, big.NewInt(16777217)),
		},
		// Exponent: 3, Sign: 0, Mantissa: 0x007fffffffffffff
		{
			`00000011` +
				`0` +
				`1111111111111111111111111111111111111111111111111111111`,
			new(big.Int).Div(oneLsh256, big.NewInt(36028797018963968)),
		},
		// Exponent: 3, Sign: 1, Mantissa: 0
		{
			`00000011` +
				`1` +
				`0000000000000000000000000000000000000000000000000000000`,
			big.NewInt(0),
		},
		//Exponent: 3, Sign: 1, Mantissa: 1 (difficultyNum = -1 and difficultyNum.Sign() = -1)
		{
			`00000011` +
				`1` +
				`0000000000000000000000000000000000000000000000000000001`,
			big.NewInt(0),
		},
		// Exponent: 3, Sign: 1, Mantissa: 65536 (difficultyNum = -65536 and difficultyNum.Sign() = -1)
		{
			`00000011` +
				`1` +
				`0000000000000000000000000000000000000010000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 3, Sign: 1, Mantissa: 16777216 (difficultyNum = -16777216 and difficultyNum.Sign() = -1)
		{
			`00000011` +
				`1` +
				`0000000000000000000000000000001000000000000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 3, Sign: 1, Mantissa: 0x007fffffffffffff
		{
			`00000011` +
				`1` +
				`1111111111111111111111111111111111111111111111111111111`,
			big.NewInt(0),
		},
		// Exponent: 7, Sign: 0, Mantissa: 0
		{
			`00000111` +
				`0` +
				`0000000000000000000000000000000000000000000000000000000`,
			big.NewInt(0),
		},
		//Exponent: 7, Sign: 1, Mantissa: 1 (difficultyNum = 4294967296 and difficultyNum.Sign() = 1)
		{
			`00000111` +
				`0` +
				`0000000000000000000000000000000000000000000000000000001`,
			new(big.Int).Div(oneLsh256, big.NewInt(4294967297)),
		},
		// Exponent: 7, Sign: 0, Mantissa: 65536 (difficultyNum = 4294967296 and difficultyNum.Sign() = 1)
		{
			`00000111` +
				`0` +
				`0000000000000000000000000000000000000010000000000000000`,
			new(big.Int).Div(oneLsh256, big.NewInt(281474976710657)),
		},
		// Exponent: 7, Sign: 0, Mantissa: 16777216 (difficultyNum = 72057594037927936 and difficultyNum.Sign() = 1)
		{
			`00000111` +
				`0` +
				`0000000000000000000000000000001000000000000000000000000`,
			new(big.Int).Div(oneLsh256, big.NewInt(72057594037927937)),
		},
		// Exponent: 7, Sign: 0, Mantissa: 0x007fffffffffffff
		{
			`00000111` +
				`0` +
				`1111111111111111111111111111111111111111111111111111111`,
			new(big.Int).Div(oneLsh256, new(big.Int).Add(big.NewInt(0).Lsh(big.NewInt(36028797018963967), 32), bigOne)),
		},
		// Exponent: 7, Sign: 1, Mantissa: 0
		{
			`00000111` +
				`1` +
				`0000000000000000000000000000000000000000000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 7, Sign: 1, Mantissa: 1 (difficultyNum = -4294967296 and difficultyNum.Sign() = -1)
		{
			`00000111` +
				`1` +
				`0000000000000000000000000000000000000000000000000000001`,
			big.NewInt(0),
		},
		// Exponent: 7, Sign: 1, Mantissa: 65536 (difficultyNum = -72057594037927936 and difficultyNum.Sign() = -1)
		{
			`00000111` +
				`1` +
				`0000000000000000000000000000000000000010000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 7, Sign: 1, Mantissa: 16777216 (difficultyNum = -154742504910672530067423232 and difficultyNum.Sign() = -1)
		{
			`00000111` +
				`1` +
				`0000000000000000000000000000001000000000000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 7, Sign: 1, Mantissa: 0x007fffffffffffff
		{
			`00000111` +
				`1` +
				`1111111111111111111111111111111111111111111111111111111`,
			big.NewInt(0),
		},
		// Exponent: 255, Sign: 0, Mantissa: 1 (difficultyNum.Sign() = 1)
		{
			`11111111` +
				`0` +
				`0000000000000000000000000000000000000000000000000000001`,
			big.NewInt(0),
		},
		// Exponent: 255, Sign: 0, Mantissa: 65536 (difficultyNum.Sign() = 1)
		{
			`11111111` +
				`0` +
				`0000000000000000000000000000000000000010000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 255, Sign: 0, Mantissa: 16777216 (difficultyNum.Sign() = 1)
		{
			`11111111` +
				`0` +
				`0000000000000000000000000000001000000000000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 255, Sign: 0, Mantissa: 0x007fffffffffffff
		{
			`11111111` +
				`0` +
				`1111111111111111111111111111111111111111111111111111111`,
			big.NewInt(0),
		},
		// Exponent: 255, Sign: 1, Mantissa: 1
		{
			`11111111` +
				`1` +
				`0000000000000000000000000000000000000000000000000000001`,
			big.NewInt(0),
		},
		// Exponent: 255, Sign: 1, Mantissa: 65536
		{
			`11111111` +
				`1` +
				`0000000000000000000000000000000000000010000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 255, Sign: 1, Mantissa: 16777216
		{
			`11111111` +
				`1` +
				`0000000000000000000000000000001000000000000000000000000`,
			big.NewInt(0),
		},
		// Exponent: 255, Sign: 1, Mantissa: 0x007fffffffffffff
		{
			`11111111` +
				`1` +
				`1111111111111111111111111111111111111111111111111111111`,
			big.NewInt(0),
		},
	}

	for i, c := range cases {
		bits, err := strconv.ParseUint(c.strBits, 2, 64)
		if err != nil {
			t.Errorf("convert string into uint error: %s\n", err)
			return
		}

		if got := CalcWork(bits); got.Cmp(c.want) != 0 {
			t.Errorf("CalcWork(%d) = %s, want %s\n", i, got, c.want)
			return
		}
	}
}

func TestCalcWork(t *testing.T) {
	testCases := []struct {
		bits uint64
		want *big.Int
	}{
		{
			0,
			big.NewInt(0),
		},
		{
			1,
			big.NewInt(0),
		},
		{
			65535,
			big.NewInt(0),
		},
		{
			16777215,
			big.NewInt(0),
		},
		{
			16777216,
			new(big.Int).Div(oneLsh256, big.NewInt(2)),
		},
		{
			4294967295,
			new(big.Int).Div(oneLsh256, big.NewInt(256)),
		},
		{
			36028797018963967,
			new(big.Int).Div(oneLsh256, big.NewInt(2147483648)),
		},
		{
			36028797018963968,
			big.NewInt(0),
		},
		{
			216172782113783808,
			big.NewInt(0),
		},
		{
			216172782113783809,
			new(big.Int).Div(oneLsh256, big.NewInt(2)),
		},
		{
			216172782130561024,
			new(big.Int).Div(oneLsh256, big.NewInt(16777217)),
		},
		{
			252201579132747775,
			new(big.Int).Div(oneLsh256, big.NewInt(36028797018963968)),
		},
		{
			252201579132747776,
			big.NewInt(0),
		},
		{
			288230376151711744,
			big.NewInt(0),
		},
		{
			288230376151711745,
			new(big.Int).Div(oneLsh256, big.NewInt(257)),
		},
		{
			540431955284459519,
			new(big.Int).Div(oneLsh256, new(big.Int).Add(big.NewInt(0).Lsh(big.NewInt(36028797018963967), 32), bigOne)),
		},
		{
			540431955284459520,
			big.NewInt(0),
		},
		{
			9223372036854775807,
			big.NewInt(0),
		},
		{
			18446744073709551615,
			big.NewInt(0),
		},
	}

	for i, c := range testCases {
		if got := CalcWork(c.bits); got.Cmp(c.want) != 0 {
			t.Errorf("test case with uint64 for CalcWork(%d) = %s, want %s\n", i, got, c.want)
			return
		}
	}
}