VALUE intersys_query_fetch(VALUE self) {
	struct rbQuery* query;
	VALUE data = Qnil;
	Data_Get_Struct(self, struct rbQuery, query);
	int num_cols = 0;
	int i = 0;
	int sql_code;

	RUN(cbind_query_fetch(query->query, &sql_code));
	
	data = rb_ary_new();

	if(sql_code == 100) {
		query->query = 1;
		rb_funcall(self, rb_intern("close"), 0);
		return data;
	}
	if(sql_code) {
		return data;
	//	rb_raise(rb_eStandardError, "Error in SQL: %d", sql_code);
	}
	
	RUN(cbind_query_get_num_cols(query->query, &num_cols));
	for(i = 0; i < num_cols; i++) {
		rb_ary_push(data, rb_funcall(self, rb_intern("get_data"), 1, INT2FIX(i+1)));
	}
	return data;
}

int main() {
    RUN(example1);
    RUN(example2);
#if WITH_THREADS
    RUN(example3);
#endif
}

char *test_State_http() 
{
    State state;

    // Simulates doing a basic HTTP request then closing the connection.
    RUN(http_dir,
            OPEN, 
            REQ_RECV, HTTP_REQ, DIRECTORY, RESP_SENT, CLOSE);

    // Simulates two keep-alive handler requests then a close.
    RUN(http_handler,
            OPEN, 
            REQ_RECV, HTTP_REQ, HANDLER, REQ_SENT,
            REQ_RECV, HTTP_REQ, HANDLER, REQ_SENT, CLOSE);

    // Simulates two requests over a proxy connection followed by
    // the remote closing the connection so we have to shutdown.
    RUN(http_proxy,
            OPEN, 
            REQ_RECV, HTTP_REQ, PROXY, CONNECT, 
            REQ_SENT, REQ_RECV, HTTP_REQ, REQ_SENT, REQ_RECV, REMOTE_CLOSE,
            CLOSE);

    // Simulates a proxy connect that needs to exit after a 
    // handler request was issued and there's a bit of data left.
    RUN(http_proxy_handler,
            OPEN, 
            REQ_RECV, HTTP_REQ, PROXY, CONNECT, 
            REQ_SENT, REQ_RECV,
            HANDLER, REQ_SENT, CLOSE);

    return NULL;
}

static int
do_test (void)
{
  int result = 0;
  int e;

#define RUN(test) \
  errno = 0;								      \
  e = test;								      \
  if (e != -1)								      \
    {									      \
      printf ("%s returned %d\n", #test, e);				      \
      result = 1;							      \
    }									      \
  else if (errno != EINVAL)						      \
    {									      \
      printf ("%s didn't set errno to EINVAL (%s instead)\n",		      \
	      #test, strerror (errno));					      \
      result = 1;							      \
    }

  RUN (sighold (-1));
  RUN (sighold (_NSIG + 100));

  RUN (sigrelse (-1));
  RUN (sigrelse (_NSIG + 100));

  return result;
}

void git::Create(LPCTSTR szOutputFile, LPCTSTR szWorkingDir, LPCTSTR szTime, LPCTSTR szUser, LPCTSTR szEmail, LPCTSTR szComment)
{
	CString sOriginalDir;
	GetCurrentDirectory(2000, sOriginalDir.GetBufferSetLength(2000));
	SetCurrentDirectory(szWorkingDir);
	
	if (!file::DoesFileExist(".git"))
	{
		CString sOutputFile = szOutputFile;
		sOutputFile.Replace("../", "../../"); //workaround

		CString sCommand;
		sCommand.Format("git init >> %s", sOutputFile);
		RUN(sCommand);

		sCommand.Format("ECHO. >> %s", sOutputFile);
		RUN(sCommand);

		sCommand.Format("ECHO. >> %s", sOutputFile);
		RUN(sCommand);

		git::Commit(szOutputFile, szWorkingDir, szTime, szUser, szEmail, szComment);
	}

	SetCurrentDirectory(sOriginalDir);
}

void ActivationFunctionsTestCase::run()
{
  RUN(ActivationFunctionsTestCase, softmax);
  RUN(ActivationFunctionsTestCase, logistic);
  RUN(ActivationFunctionsTestCase, normaltanh);
  RUN(ActivationFunctionsTestCase, linear);
  RUN(ActivationFunctionsTestCase, rectifier);
}

int main(int argc, char** argv) {
    tl_init();
    RUN(num_new);
    RUN(build_and_print);
    RUN(basic);
    RUN(mul);
    RUN(pow);
}

int main (int argc, char * argv[]){
	printf ("Basics Testcase\n");
	RUN (StructureParser::test_matchTypeName());
	RUN (StructureParser::test_matchCppType());
	RUN (StructureParser::test_matchVariableDefinition());
	RUN (StructureParser::test_matchFunctionDeclaration());
	return 0;
}

VALUE intersys_query_column_name(VALUE self, VALUE i) {
	struct rbQuery* query;
	Data_Get_Struct(self, struct rbQuery, query);
	int len;
	const wchar_t *res;
	RUN(cbind_query_get_col_name_len(query->query, FIX2INT(i), &len));
	RUN(cbind_query_get_col_name(query->query, FIX2INT(i), &res));
	return FROMWCSTR(res);
}

int main(int argc, char ** argv) {

	RUN(test_basic_diffusion);
	RUN(test_near_borders);
	RUN(test_border_temperatures);
	RUN(test_on_border_edge_case);

	return TEST_REPORT();
}

int run_perftest(maincontext_t* maincontext)
{
   (void) maincontext;

   RUN(perftest_task_syncrunner);
   RUN(perftest_task_syncrunner_raw);

   return 0;
}

VALUE intersys_query_execute(VALUE self) {
	struct rbQuery* query;
	int sql_code;
	int res;
	Data_Get_Struct(self, struct rbQuery, query);
	RUN(cbind_query_execute(query->query, &sql_code));
    RUN(cbind_query_get_num_pars(query->query, &res));
	query->executed = 1;
	return self;
}

int main(void)
{
    RUN(fix16_exp_unittests);
    RUN(fix16_macros_unittests);
    RUN(fix16_str_unittests);
    RUN(fix16_unittests);

    puts("SUCCESS");
    return 0;
}

int
main (void) {

  RUN(value);
  RUN(var);

  RUN(lexer);

  ok_done();
  return 0;
}

VALUE intersys_query_initialize(VALUE self, VALUE database, VALUE sql_query) {
	struct rbQuery* query;
	struct rbDatabase* base;
	int sql_code;
	Data_Get_Struct(self, struct rbQuery, query);
	Data_Get_Struct(database, struct rbDatabase, base);
	rb_iv_set(self, "@database", database);
	query->limit = -1;
	RUN(cbind_alloc_query(base->database, &query->query));
	RUN(cbind_prepare_gen_query(query->query, WCHARSTR(TOWCHAR(sql_query)), &sql_code));
	return self;
}

void interrupt 20 RxInterrupt(void)
{
    DisableInterrupts;
    if( SCI0SR1 & 0x20 )
    {
        CaptureCommand = SCI0DRL;
    }
    switch(CaptureCommand)
    {
        case '0':
            BREAK();isbreak = 1;constant_speed = 0;
            break;
        case '9':
            RUN();debug = 0;isbreak = 0;constant_speed = 450;
            break;
        case 'b':
            STOP();constant_speed = 0;
            break;
        case 'c':
            STOP();constant_speed = 0;
            break;
        case 'd':
            debug = 1;STOP();constant_speed = 0;
            break;
        default:
            break;
    }
    EnableInterrupts;
}

int test_singlefile()
{
  SETUP;

  CHECK_SET_INTERFACE(singlefile);

  CHECK("get option (rib-file)",
        (option =
         bgpstream_get_data_interface_option_by_name(bs, datasource_id,
                                                     "rib-file")) != NULL);
  bgpstream_set_data_interface_option(bs, option,
                           "routeviews.route-views.jinx.ribs.1427846400.bz2");

  CHECK("get option (upd-file)",
        (option =
         bgpstream_get_data_interface_option_by_name(bs, datasource_id,
                                                     "upd-file")) != NULL);
  bgpstream_set_data_interface_option(bs, option,
                                      "ris.rrc06.updates.1427846400.gz");

  RUN(singlefile);

  TEARDOWN;
  return 0;
}

void lcd_init_device(void)
{
    semaphore_init(&g_wait_sema, 1, 0);
    /* I'm not really sure this pin is related to power, it does not seem to do anything */
    imx233_pinctrl_acquire(1, 8, "lcd_power");
    imx233_pinctrl_acquire(1, 9, "lcd_spi_sdo");
    imx233_pinctrl_acquire(1, 10, "lcd_spi_scl");
    imx233_pinctrl_acquire(1, 11, "lcd_spi_cs");
    imx233_pinctrl_set_function(1, 9, PINCTRL_FUNCTION_GPIO);
    imx233_pinctrl_set_function(1, 10, PINCTRL_FUNCTION_GPIO);
    imx233_pinctrl_set_function(1, 11, PINCTRL_FUNCTION_GPIO);
    imx233_pinctrl_set_function(1, 8, PINCTRL_FUNCTION_GPIO);
    imx233_pinctrl_enable_gpio(1, 8, true);
    /** lcd is 320x240, data bus is 8-bit, depth is 24-bit so we need 3clk/pix
     * by running PIX clock at 24MHz we can sustain ~100 fps */
    imx233_clkctrl_enable(CLK_PIX, false);
    imx233_clkctrl_set_div(CLK_PIX, 2);
    imx233_clkctrl_set_bypass(CLK_PIX, true); /* use XTAL */
    imx233_clkctrl_enable(CLK_PIX, true);
    imx233_lcdif_init();
    imx233_lcdif_setup_dotclk_pins(8, false);
    imx233_lcdif_set_word_length(8);
    imx233_lcdif_set_underflow_cb(&lcd_underflow);
    imx233_lcdif_enable_underflow_irq(true);
    imx233_dma_clkgate_channel(APB_LCDIF, true);
    imx233_dma_reset_channel(APB_LCDIF);
    /** Datasheet states:
     * 257H >= VBP >= 3H, VBP > VLW, VFP >= 1H
     * 1533clk >= HBP >= 24clk, HBP > HLW, HFP >= 4clk
     * 
     * Take VLW=1H, VBP=3H, VFP=1H, HLW=8, HBP=24, HFP=4
     * Take 3clk/pix because we send 24-bit/pix with 8-bit data bus
     * Keep consistent with register setting in lcd_init_seq
     */
    imx233_lcdif_setup_dotclk_ex(/*v_pulse_width*/1, /*v_back_porch*/3,
        /*v_front_porch*/1, /*h_pulse_width*/8, /*h_back_porch*/24,
        /*h_front_porch*/4, LCD_WIDTH, LCD_HEIGHT, /*clk_per_pix*/3,
        /*enable_present*/false);
    imx233_lcdif_set_byte_packing_format(0xf);
    imx233_lcdif_enable_sync_signals(true); // we need frame signals during init
    // setup dma
    unsigned size = IMX233_FRAMEBUFFER_SIZE;
    uint8_t *frame_p = FRAME;
    for(int i = 0; i < NR_CMDS; i++)
    {
        unsigned xfer = MIN(IMX233_MAX_SINGLE_DMA_XFER_SIZE, size);
        lcdif_dma[i].dma.next = &lcdif_dma[(i + 1) % NR_CMDS].dma;
        lcdif_dma[i].dma.cmd = BF_OR3(APB_CHx_CMD, CHAIN(1),
            COMMAND(BV_APB_CHx_CMD_COMMAND__READ), XFER_COUNT(xfer));
        lcdif_dma[i].dma.buffer =  frame_p;
        size -= xfer;
        frame_p += xfer;
    }
    // first transfer: enable run, dotclk and so on
    lcdif_dma[0].dma.cmd |= BF_OR1(APB_CHx_CMD, CMDWORDS(1));
    lcdif_dma[0].ctrl = BF_OR4(LCDIF_CTRL, BYPASS_COUNT(1), DOTCLK_MODE(1),
        RUN(1), WORD_LENGTH(1));
    // enable
    lcd_enable(true);
}

void intersys_query_free(struct rbQuery* query) {
	if(!query->closed && query->executed) {
		query_close(query);
		RUN(cbind_free_query(query->query));
		xfree(query);
	}
}

VALUE intersys_base_level(VALUE self) {
	struct rbDatabase* base;
	int level;
	Data_Get_Struct(self, struct rbDatabase, base);
	RUN(cbind_tlevel(base->database, &level));
	return INT2FIX(level);
}