#+test

package zmq

import "base:runtime"
import "core:testing"

@(test)
test_version :: proc(t: ^testing.T) {
	ma, mi, pa := version()

	testing.expect_value(t, ma, 4)
	testing.expect_value(t, mi, 3)
	testing.expect_value(t, pa, 5)
}

@(test)
test_connect_does_not_allocate_with_string_literals :: proc(t: ^testing.T) {
	context.allocator = runtime.panic_allocator()
	context.temp_allocator = runtime.panic_allocator()

	ctx := ctx_new()
	defer ctx_term(ctx)

	srv, serr := socket(ctx, .REP)
	testing.expect_value(t, serr, nil)
	if serr != nil {
		testing.fail_now(t, "Can't create server socket")
	}
	defer close(srv)

	if err := bind(srv, "inproc://echo"); err != nil {
		testing.expect_value(t, err, nil)
		testing.fail_now(t, "Can't bind server socket")
	}

	cli, cerr := socket(ctx, .REQ)
	testing.expect_value(t, cerr, nil)
	if cerr != nil {
		testing.fail_now(t, "Can't create client socket")
	}
	defer close(cli)
	err := connect(cli, "inproc://echo")
	testing.expect_value(t, err, nil)
	if err != nil {
		testing.fail_now(t, "Can't connect client to server")
	}
}

@(test)
test_simple_const_echo :: proc(t: ^testing.T) {
	ctx := ctx_new()
	defer ctx_term(ctx)

	srv, serr := socket(ctx, .REP)
	testing.expect_value(t, serr, nil)
	if serr != nil {
		testing.fail_now(t, "Can't create server socket")
	}
	defer close(srv)

	if err := bind(srv, "inproc://echo"); err != nil {
		testing.expect_value(t, err, nil)
		testing.fail_now(t, "Can't bind server socket")
	}

	cli, cerr := socket(ctx, .REQ)
	testing.expect_value(t, cerr, nil)
	if cerr != nil {
		testing.fail_now(t, "Can't create client socket")
	}
	defer close(cli)
	err := connect(cli, "inproc://echo")
	testing.expect_value(t, err, nil)
	if err != nil {
		testing.fail_now(t, "Can't connect client to server")
	}

	msg :: "Hello, World"
	buf: [len(msg)]u8

	_, err = send_const(cli, msg)
	testing.expect_value(t, err, nil)
	if err != nil {
		testing.fail_now(t, "Can't send message")
	}

	{
		n := 0
		n, err = recv(srv, buf[:])
		testing.expect_value(t, n, len(msg))
		testing.expect_value(t, err, nil)
		if err != nil || n != len(msg) {
			testing.fail_now(t, "Can't receive message")
		}

		testing.expect_value(t, string(buf[:n]), string(msg))

		_, err := send(srv, buf[:n])
		testing.expect_value(t, err, nil)
		if err != nil {
			testing.fail_now(t, "Can't send message")
		}
	}

	{
		m := 0
		m, err = recv(cli, buf[:])
		testing.expect_value(t, m, len(msg))
		testing.expect_value(t, err, nil)
		if err != nil || m != len(msg) {
			testing.fail_now(t, "Can't receive message")
		}

		testing.expect_value(t, string(buf[:m]), string(msg))
	}
}

@(test)
test_duplicate_bind_fails :: proc(t: ^testing.T) {
	ctx := ctx_new()
	defer ctx_term(ctx)

	rep1, serr := socket(ctx, .REP)
	testing.expect_value(t, serr, nil)
	if serr != nil {
		testing.fail_now(t, "create first socket")
	}
	defer close(rep1)

	if berr := bind(rep1, "inproc://duplicate"); berr != nil {
		testing.expect_value(t, berr, nil)
		testing.fail_now(t, "first bind should succeed")
	}

	rep2, cerr := socket(ctx, .REP)
	testing.expect_value(t, cerr, nil)
	if cerr != nil {
		testing.fail_now(t, "create second socket")
	}
	defer close(rep2)

	if berr := bind(rep2, "inproc://duplicate"); berr == nil {
		testing.fail_now(t, "second bind to same endpoint should fail with EADDRINUSE")
	} else {
		testing.expect_value(t, berr, ZMQ_Error.EADDRINUSE)
	}
}