/***********************************************************************************
 * Chaga string arithmetic library                                                 *
 * Copyright (C) 2026 Robert James Bruce                                           *
 *                                                                                 *
 * This file is part of the Chaga string arithmetic library.                       *
 *                                                                                 *
 * The Chaga string arithmetic library is free software: you can redistribute it   * 
 * and/or modify it under the terms of the GNU General Public License as published *
 * by the Free Software Foundation, either version 3 of the License, or (at your   *
 * option) any later version.                                                      *
 *                                                                                 *
 * The Chaga string arithmetic library is distributed in the hope that it will be  *
 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public *
 * License for more details.                                                       *
 *                                                                                 *
 * You should have received a copy of the GNU General Public License               *
 * along with the Chaga compiler. If not, see <https://www.gnu.org/licenses/>.     *
 ***********************************************************************************/
#include "include/libchaga-tests.h"




// *************
// * Test 1: 0 *
// *************
void integer_result_postfix_expression_test1 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", FALSE);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 1: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 1: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 1: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************
// * Test 2: 12 *
// **************
void integer_result_postfix_expression_test2 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", FALSE);
  correct_result = packed_string_integer_set_value (correct_result, "12");
  printf ("Test 2: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 2: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 2: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ****************
// * Test 3: TRUE *
// ****************
void integer_result_postfix_expression_test3 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 3: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 3: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 3: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************
// * Test 4: FALSE *
// *****************
void integer_result_postfix_expression_test4 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", FALSE);
  correct_result = packed_string_integer_initialize_to_zero(correct_result);
  printf ("Test 4: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 4: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 4: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 5: 54321.12345 *
// ***********************
void integer_result_postfix_expression_test5 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", FALSE);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 5: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 5: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 5: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************
// * Test 6: i1 *
// **************
void integer_result_postfix_expression_test6 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 6: i1\n");
  printf ("Test 6: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 6: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 6: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **************
// * Test 7: f1 *
// **************
void integer_result_postfix_expression_test7 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 7: f1\n");
  printf ("Test 7: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 7: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 7: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **************
// * Test 8: b1 *
// **************
void integer_result_postfix_expression_test8 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  { 
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 8: b1\n");
  printf ("Test 8: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 8: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 8: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************
// * Test 9: 0 NOT *
// *****************
void integer_result_postfix_expression_test9 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 9: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 9: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 9: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************
// * Test 10: 12 NOT *
// *******************
void integer_result_postfix_expression_test10 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 10: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 10: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 10: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}





// *********************
// * Test 11: TRUE NOT *
// *********************
void integer_result_postfix_expression_test11 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 11: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 11: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 11: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **********************
// * Test 12: FALSE NOT *
// **********************
void integer_result_postfix_expression_test12 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not);
  correct_result = packed_string_integer_set_value(correct_result, "1");
  printf ("Test 12: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 12: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 12: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ****************************
// * Test 13: 54321.12345 NOT *
// ****************************
void integer_result_postfix_expression_test13 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not);
  correct_result = packed_string_integer_initialize_to_zero(correct_result);
  printf ("Test 13: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 13: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 13: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 13: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 13: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}





// *******************
// * Test 14: i1 NOT *
// *******************
void integer_result_postfix_expression_test14 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 14: i1 NOT\n");
  printf ("Test 14: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 14: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 14: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 14: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 14: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *******************
// * Test 15: f1 NOT *
// *******************
void integer_result_postfix_expression_test15 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 15: f1 NOT\n");
  printf ("Test 15: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 15: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 15: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 15: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 15: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *******************
// * Test 16: b1 NOT *
// *******************
void integer_result_postfix_expression_test16 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 16: b1 NOT\n");
  printf ("Test 16: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 16: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 16: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 16: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 16: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *******************
// * Test 17: 12 2 + *
// *******************
void integer_result_postfix_expression_test17 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "14");
  printf ("Test 17: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 17: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 17: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 17: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 17: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************
// * Test 18: 12 2 - *
// *******************
void integer_result_postfix_expression_test18 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "10");
  printf ("Test 18: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 18: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 18: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 18: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 18: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************
// * Test 19: 12 2 * *
// *******************
void integer_result_postfix_expression_test19 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "24");
  printf ("Test 19: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 19: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 19: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 19: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 19: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************
// * Test 20: 12 2 / *
// *******************
void integer_result_postfix_expression_test20 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "6");
  printf ("Test 20: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 20: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 20: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 20: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 20: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************
// * Test 21: 12 2 % *
// *******************
void integer_result_postfix_expression_test21 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 21: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 21: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 21: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 21: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *********************
// * Test 22: 12 2 AND *
// *********************
void integer_result_postfix_expression_test22 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");

  printf ("Test 22: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 22: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 22: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 22: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************
// * Test 23: 12 2 OR *
// ********************
void integer_result_postfix_expression_test23 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 23: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 23: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 23: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 23: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 23: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *********************
// * Test 24: 12 2 XOR *
// *********************
void integer_result_postfix_expression_test24 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 24: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 24: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 24: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 24: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 24: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************
// * Test 25: 12 2 >= *
// ********************
void integer_result_postfix_expression_test25 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 25: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 25: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 25: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 25: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 25: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************
// * Test 26: 12 2 > *
// *******************
void integer_result_postfix_expression_test26 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 26: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 26: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 26: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 26: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 26: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************
// * Test 27: 12 2 <= *
// ********************
void integer_result_postfix_expression_test27 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 27: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 27: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 27: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 27: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 27: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************
// * Test 28: 12 2 < *
// *******************
void integer_result_postfix_expression_test28 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 28: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 28: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 28: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 28: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 28: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************
// * Test 29: 12 2 != *
// ********************
void integer_result_postfix_expression_test29 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 29: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 29: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 29: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 29: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 29: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************
// * Test 30: 12 2 == *
// ********************
void integer_result_postfix_expression_test30 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 30: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 30: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 30: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 30: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 30: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 31: TRUE TRUE >= *
// *************************
void integer_result_postfix_expression_test31 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 31: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 31: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 31: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 31: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 31: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ************************
// * Test 32: TRUE TRUE > *
// ************************
void integer_result_postfix_expression_test32 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 32: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 32: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 32: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 32: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 32: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 33: TRUE TRUE <= *
// *************************
void integer_result_postfix_expression_test33 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 33: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 33: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 33: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 33: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 33: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ************************
// * Test 34: TRUE TRUE < *
// ************************
void integer_result_postfix_expression_test34 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 34: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 34: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 34: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 34: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 34: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 35: TRUE TRUE != *
// *************************
void integer_result_postfix_expression_test35 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 35: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 35: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 35: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 35: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 35: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 36: TRUE TRUE != *
// *************************
void integer_result_postfix_expression_test36 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 36: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 36: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 36: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 36: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 36: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 37: FALSE TRUE >= *
// **************************
void integer_result_postfix_expression_test37 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 37: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 37: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 37: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 37: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 37: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 38: FALSE TRUE > *
// *************************
void integer_result_postfix_expression_test38 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 38: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 38: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 38: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 38: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 38: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 39: FALSE TRUE <= *
// **************************
void integer_result_postfix_expression_test39 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 39: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 39: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 39: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 39: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 39: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}



// *************************
// * Test 40: FALSE TRUE < *
// *************************
void integer_result_postfix_expression_test40 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 40: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 40: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 40: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 40: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 40: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 41: FALSE TRUE != *
// **************************
void integer_result_postfix_expression_test41 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 41: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 41: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 41: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 41: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 41: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}



// **************************
// * Test 42: FALSE TRUE == *
// **************************
void integer_result_postfix_expression_test42 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 42: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 42: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 42: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 42: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 42: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 43: FALSE TRUE >= *
// **************************
void integer_result_postfix_expression_test43 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 43: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 43: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 43: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 43: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 43: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 44: FALSE TRUE > *
// *************************
void integer_result_postfix_expression_test44 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 44: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 44: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 44: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 44: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 44: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 45: FALSE TRUE <= *
// **************************
void integer_result_postfix_expression_test45 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 45: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 45: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 45: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 45: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 45: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 46: FALSE TRUE < *
// *************************
void integer_result_postfix_expression_test46 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 46: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 46: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 46: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 46: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 46: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 47: FALSE TRUE != *
// **************************
void integer_result_postfix_expression_test47 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 47: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 47: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 47: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 47: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 47: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}



// **************************
// * Test 48: FALSE TRUE == *
// **************************
void integer_result_postfix_expression_test48 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 48: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 48: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 48: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 48: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 48: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 49: 1 FALSE >= *
// ***********************
void integer_result_postfix_expression_test49 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 49: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 49: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 49: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 49: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 49: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **********************
// * Test 50: 1 FALSE > *
// **********************
void integer_result_postfix_expression_test50 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 50: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 50: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 50: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 50: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 50: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 51: 1 FALSE <= *
// ***********************
void integer_result_postfix_expression_test51 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 51: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 51: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 51: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 51: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 51: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **********************
// * Test 52: 1 FALSE < *
// **********************
void integer_result_postfix_expression_test52 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 52: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 52: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 52: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 52: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 52: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 53: 1 FALSE != *
// ***********************
void integer_result_postfix_expression_test53 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 53: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 53: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 53: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 53: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 53: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 54: 1 FALSE != *
// ***********************
void integer_result_postfix_expression_test54 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 54: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 54: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 54: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 54: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 54: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 55: FALSE 1 >= *
// ***********************
void integer_result_postfix_expression_test55 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 55: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 55: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 55: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 55: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 55: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **********************
// * Test 56: FALSE 1 > *
// **********************
void integer_result_postfix_expression_test56 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 56: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 56: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 56: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 56: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 56: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 57: FALSE 1 <= *
// ***********************
void integer_result_postfix_expression_test57 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 57: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 57: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 57: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 57: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 57: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **********************
// * Test 58: FALSE 1 < *
// **********************
void integer_result_postfix_expression_test58 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 58: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 58: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 58: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 58: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 58: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 59: FALSE 1 != *
// ***********************
void integer_result_postfix_expression_test59 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 59: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 59: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 59: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 59: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 59: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ***********************
// * Test 60: FALSE 1 == *
// ***********************
void integer_result_postfix_expression_test60 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 60: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 60: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 60: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 60: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 60: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 61: FALSE 0 -1 >= *
// **************************
void integer_result_postfix_expression_test61 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 61: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 61: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 61: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 61: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 61: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 62: FALSE 0 -1 > *
// *************************
void integer_result_postfix_expression_test62 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 62: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 62: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 62: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 62: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 62: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 63: FALSE 0 -1 > *
// *************************
void integer_result_postfix_expression_test63 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 63: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 63: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 63: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 63: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 63: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *************************
// * Test 64: FALSE 0 -1 < *
// *************************
void integer_result_postfix_expression_test64 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 64: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 64: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 64: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 64: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 64: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 65: FALSE 0 -1 != *
// **************************
void integer_result_postfix_expression_test65 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 65: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 65: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 65: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 65: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 65: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// **************************
// * Test 66: FALSE 0 -1 == *
// **************************
void integer_result_postfix_expression_test66 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-1", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 66: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 66: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 66: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 66: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 66: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ****************************
// * Test 67: 54321.12345 0 + *
// ****************************
void integer_result_postfix_expression_test67 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 67: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 67: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 67: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 67: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 67: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ****************************
// * Test 68: 54321.12345 0 - *
// ****************************
void integer_result_postfix_expression_test68 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 68: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 68: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 68: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 68: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 68: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ****************************
// * Test 69: 54321.12345 0 * *
// ****************************
void integer_result_postfix_expression_test69 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 69: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 69: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 69: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 69: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 69: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ****************************
// * Test 70: 54321.12345 0 * *
// ****************************
void integer_result_postfix_expression_test70 (void)
{
  runtime_expression_node *expression;
  psint *result;

  expression = NULL;
  result     = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  printf ("Test 70: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  printf ("Test 70: result = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if (result != NULL)
  {
    if (result->sign == undefined)
    {
      printf ("Test 70: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 70: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
    result = packed_string_integer_release_memory (result);
  }
  else
  {
    printf ("Test 70: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  printf ("\n");
}




// ****************************
// * Test 71: 54321.12345 0 * *
// ****************************
void integer_result_postfix_expression_test71 (void)
{
  runtime_expression_node *expression;
  psint *result;

  expression = NULL;
  result     = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  printf ("Test 71: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  printf ("Test 71: result = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if (result != NULL)
  {
    if (result->sign == undefined)
    {
      printf ("Test 71: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 71: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
    result = packed_string_integer_release_memory (result);
  }
  else
  {
    printf ("Test 71: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  printf ("\n");
}




// ****************************
// * Test 72: 54321.12345 0 * *
// ****************************
void integer_result_postfix_expression_test72 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 72: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 72: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 72: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 72: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 72: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 73: 54321.12345 0 OR *
// *****************************
void integer_result_postfix_expression_test73 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 73: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 73: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 73: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 73: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 73: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 74: 54321.12345 0 XOR *
// ******************************
void integer_result_postfix_expression_test74 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 74: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 74: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 74: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 74: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 74: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 75: 54321.12345 0 >= *
// *****************************
void integer_result_postfix_expression_test75 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 75: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 75: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 75: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 75: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 75: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ****************************
// * Test 76: 54321.12345 0 > *
// ****************************
void integer_result_postfix_expression_test76 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 76: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 76: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 76: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 76: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 76: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 77: 54321.12345 0 <= *
// *****************************
void integer_result_postfix_expression_test77 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 77: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 77: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 77: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 77: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 77: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ****************************
// * Test 78: 54321.12345 0 < *
// ****************************
void integer_result_postfix_expression_test78 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 78: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 78: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 78: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 78: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 78: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 79: 54321.12345 0 != *
// *****************************
void integer_result_postfix_expression_test79 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 79: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 79: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 79: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 79: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 79: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 80: 54321.12345 0 == *
// *****************************
void integer_result_postfix_expression_test80 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "0", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 80: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 80: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 80: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 80: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 80: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 81: 54321.999 1.555 + *
// ******************************
void integer_result_postfix_expression_test81 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54323");
  printf ("Test 81: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 81: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 81: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 81: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 81: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 82: 54321.999 1.555 - *
// ******************************
void integer_result_postfix_expression_test82 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "54320");
  printf ("Test 82: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 82: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 82: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 82: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 82: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 83: 54321.999 1.555 * *
// ******************************
void integer_result_postfix_expression_test83 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "84470");
  printf ("Test 83: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 83: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 83: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 83: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 83: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 84: 54321.999 1.555 / *
// ******************************
void integer_result_postfix_expression_test84 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "34933");
  printf ("Test 84: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 84: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 84: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 84: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 84: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 85: 54321.999 1.555 % *
// ******************************
void integer_result_postfix_expression_test85 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 85: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 85: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 85: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 85: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 85: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 86: 54321.999 1.555 AND *
// ********************************
void integer_result_postfix_expression_test86 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 86: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 86: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 86: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 86: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 86: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 87: 54321.999 1.555 OR *
// *******************************
void integer_result_postfix_expression_test87 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 87: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 87: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 87: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 87: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 87: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 88: 54321.999 1.555 XOR *
// ********************************
void integer_result_postfix_expression_test88 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 88: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 88: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 88: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 88: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 88: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 89: 54321.999 1.555 >= *
// *******************************
void integer_result_postfix_expression_test89 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 89: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 89: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 89: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 89: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 89: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 90: 54321.999 1.555 > *
// ******************************
void integer_result_postfix_expression_test90 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 90: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 90: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 90: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 90: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 90: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 91: 54321.999 1.555 <= *
// *******************************
void integer_result_postfix_expression_test91 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 91: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 91: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 91: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 91: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 91: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 92: 54321.999 1.555 < *
// ******************************
void integer_result_postfix_expression_test92 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 92: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 92: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 92: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 92: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 92: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 93: 54321.999 1.555 != *
// *******************************
void integer_result_postfix_expression_test93 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 93: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 93: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 93: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 93: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 93: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 94: 54321.999 1.555 == *
// *******************************
void integer_result_postfix_expression_test94 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "1.555", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 94: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 94: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 94: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 94: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 94: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 95: 54321.999 TRUE + *
// *****************************
void integer_result_postfix_expression_test95 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54322");
  printf ("Test 95: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 95: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 95: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 95: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 95: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 96: 54321.999 TRUE + *
// *****************************
void integer_result_postfix_expression_test96 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "54320");
  printf ("Test 96: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 96: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 96: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 96: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 96: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 97: 54321.999 TRUE * *
// *****************************
void integer_result_postfix_expression_test97 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 97: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 97: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 97: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 97: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 97: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 98: 54321.999 TRUE / *
// *****************************
void integer_result_postfix_expression_test98 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 98: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 98: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 98: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 98: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 98: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *****************************
// * Test 99: 54321.999 TRUE % *
// *****************************
void integer_result_postfix_expression_test99 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 99: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 99: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 99: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 99: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 99: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 100: 54321.999 TRUE AND *
// ********************************
void integer_result_postfix_expression_test100 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 100: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 100: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 100: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 100: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 100: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 101: 54321.999 TRUE OR *
// *******************************
void integer_result_postfix_expression_test101 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 101: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 101: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 101: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 101: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 101: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 102: 54321.999 TRUE XOR *
// ********************************
void integer_result_postfix_expression_test102 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 102: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 102: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 102: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 102: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 102: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 103: 54321.999 TRUE >= *
// *******************************
void integer_result_postfix_expression_test103 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 103: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 103: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 103: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 103: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 103: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 104: 54321.999 TRUE > *
// ******************************
void integer_result_postfix_expression_test104 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 104: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 104: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 104: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 104: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 104: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 105: 54321.999 TRUE <= *
// *******************************
void integer_result_postfix_expression_test105 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 105: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 105: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 105: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 105: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 105: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ******************************
// * Test 106: 54321.999 TRUE < *
// ******************************
void integer_result_postfix_expression_test106 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 106: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 106: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 106: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 106: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 106: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 107: 54321.999 TRUE != *
// *******************************
void integer_result_postfix_expression_test107 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 107: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 107: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 107: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 107: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 107: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 108: 54321.999 TRUE == *
// *******************************
void integer_result_postfix_expression_test108 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 108: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 108: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 108: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 108: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 108: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 109: FALSE 54321.999 + *
// *******************************
void integer_result_postfix_expression_test109 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 109: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 109: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 109: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 109: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 109: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 110: FALSE 54321.999 - *
// *******************************
void integer_result_postfix_expression_test110 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-54321");
  printf ("Test 110: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 110: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 110: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 110: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 110: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 111: FALSE 54321.999 * *
// *******************************
void integer_result_postfix_expression_test111 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 111: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 111: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 111: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 111: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 111: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 112: FALSE 54321.999 / *
// *******************************
void integer_result_postfix_expression_test112 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 112: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 112: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 112: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 112: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 112: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 113: FALSE 54321.999 % *
// *******************************
void integer_result_postfix_expression_test113 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 113: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 113: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 113: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 113: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 113: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 114: FALSE 54321.999 >= *
// ********************************
void integer_result_postfix_expression_test114 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 114: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 114: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 114: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 114: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 114: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 115: FALSE 54321.999 > *
// *******************************
void integer_result_postfix_expression_test115 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 115: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 115: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 115: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 115: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 115: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 116: FALSE 54321.999 <= *
// ********************************
void integer_result_postfix_expression_test116 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 116: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 116: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 116: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 116: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 116: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 117: FALSE 54321.999 < *
// *******************************
void integer_result_postfix_expression_test117 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 117: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 117: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 117: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 117: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 117: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 118: FALSE 54321.999 != *
// ********************************
void integer_result_postfix_expression_test118 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 118: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 118: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 118: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 118: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 118: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 119: FALSE 54321.999 == *
// ********************************
void integer_result_postfix_expression_test119 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 119: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 119: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 119: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 119: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 119: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 120: FALSE 54321.999 >= *
// ********************************
void integer_result_postfix_expression_test120 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 120: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 120: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 120: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 120: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 120: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// *******************************
// * Test 121: FALSE 54321.999 > *
// *******************************
void integer_result_postfix_expression_test121 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 121: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 121: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 121: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 121: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 121: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 122: FALSE 54321.999 <= *
// ********************************
void integer_result_postfix_expression_test122 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 122: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 122: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 122: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 122: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 122: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}



// *******************************
// * Test 123: FALSE 54321.999 < *
// *******************************
void integer_result_postfix_expression_test123 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 123: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 123: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 123: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 123: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 123: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 124: FALSE 54321.999 != *
// ********************************
void integer_result_postfix_expression_test124 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 124: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 124: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 124: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 124: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 124: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}




// ********************************
// * Test 125: FALSE 54321.999 == *
// ********************************
void integer_result_postfix_expression_test125 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", TRUE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 125: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 125: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 125: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 125: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 125: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}



// **********************
// * Test 126: i1 -23 + *
// **********************
void integer_result_postfix_expression_test126 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "100");
  printf ("Test 126: i1 -23 +\n");
  printf ("Test 126: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 126: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 126: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 126: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 126: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 127: i1 -23 - *
// **********************
void integer_result_postfix_expression_test127 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "146");
  printf ("Test 127: i1 -23 -\n");
  printf ("Test 127: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 127: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 127: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 127: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 127: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 128: i1 -23 * *
// **********************
void integer_result_postfix_expression_test128 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "-2829");
  printf ("Test 128: i1 -23 *\n");
  printf ("Test 128: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 128: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 128: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 128: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 128: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 129: i1 -23 / *
// **********************
void integer_result_postfix_expression_test129 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "-5");
  printf ("Test 129: i1 -23 /\n");
  printf ("Test 129: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 129: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 129: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 129: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 129: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 130: i1 -23 % *
// **********************
void integer_result_postfix_expression_test130 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "8");
  printf ("Test 130: i1 -23 %%\n");
  printf ("Test 130: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 130: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 130: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 130: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 130: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 131: i1 -23 AND *
// ************************
void integer_result_postfix_expression_test131 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 131: i1 -23 AND\n");
  printf ("Test 131: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 131: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 131: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 131: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 131: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 132: i1 -23 OR *
// ***********************
void integer_result_postfix_expression_test132 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 132: i1 -23 OR\n");
  printf ("Test 132: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 132: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 132: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 132: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 132: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 133: i1 -23 XOR *
// ************************
void integer_result_postfix_expression_test133 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 133: i1 -23 XOR\n");
  printf ("Test 133: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 133: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 133: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 133: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 133: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 134: i1 -23 >= *
// ***********************
void integer_result_postfix_expression_test134 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 134: i1 -23 >=\n");
  printf ("Test 134: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 134: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 134: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 134: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 134: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// **********************
// * Test 135: i1 -23 > *
// **********************
void integer_result_postfix_expression_test135 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 135: i1 -23 >\n");
  printf ("Test 135: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 135: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 135: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 135: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 135: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 136: i1 -23 <= *
// ***********************
void integer_result_postfix_expression_test136 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 136: i1 -23 <=\n");
  printf ("Test 136: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 136: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 136: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 136: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 136: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// **********************
// * Test 137: i1 -23 < *
// **********************
void integer_result_postfix_expression_test137 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 137: i1 -23 <\n");
  printf ("Test 137: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 137: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 137: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 137: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 137: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 138: i1 -23 != *
// ***********************
void integer_result_postfix_expression_test138 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 138: i1 -23 !=\n");
  printf ("Test 138: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 138: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 138: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 138: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 138: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 139: i1 -23 == *
// ***********************
void integer_result_postfix_expression_test139 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 139: i1 -23 ==\n");
  printf ("Test 139: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 139: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 139: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 139: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 139: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// **********************
// * Test 140: -23 i1 + *
// **********************
void integer_result_postfix_expression_test140 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "100");
  printf ("Test 140: -23 i1 +\n");
  printf ("Test 140: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 140: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 140: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 140: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 140: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 141: -23 i1 - *
// **********************
void integer_result_postfix_expression_test141 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-146");
  printf ("Test 141: -23 i1 -\n");
  printf ("Test 141: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 141: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 141: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 141: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 141: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 142: -23 i1 * *
// **********************
void integer_result_postfix_expression_test142 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "-2829");
  printf ("Test 142: -23 i1 *\n");
  printf ("Test 142: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 142: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 142: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 142: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 142: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 143: -23 i1 / *
// **********************
void integer_result_postfix_expression_test143 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 143: -23 i1 /\n");
  printf ("Test 143: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 143: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 143: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 143: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 143: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 144: -23 i1 % *
// **********************
void integer_result_postfix_expression_test144 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "-23");
  printf ("Test 144: -23 i1 %%\n");
  printf ("Test 144: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 144: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 144: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 144: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 144: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ************************
// * Test 145: -23 i1 AND *
// ************************
void integer_result_postfix_expression_test145 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 145: -23 i1 AND\n");
  printf ("Test 145: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 145: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 145: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 145: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 145: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 146: -23 i1 OR *
// ***********************
void integer_result_postfix_expression_test146 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 146: -23 i1 OR\n");
  printf ("Test 146: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 146: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 146: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 146: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 146: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 147: -23 i1 XOR *
// ************************
void integer_result_postfix_expression_test147 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 147: -23 i1 XOR\n");
  printf ("Test 147: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 147: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 147: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 147: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 147: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 148: -23 i1 >= *
// ***********************
void integer_result_postfix_expression_test148 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 148: -23 i1 >=\n");
  printf ("Test 148: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 148: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 148: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 148: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 148: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 149: -23 i1 > *
// **********************
void integer_result_postfix_expression_test149 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 149: -23 i1 >\n");
  printf ("Test 149: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 149: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 149: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 149: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 149: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 150: -23 i1 <= *
// ***********************
void integer_result_postfix_expression_test150 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 150: -23 i1 <=\n");
  printf ("Test 150: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 150: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 150: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 150: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 150: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// **********************
// * Test 151: -23 i1 < *
// **********************
void integer_result_postfix_expression_test151 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 151: -23 i1 <\n");
  printf ("Test 151: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 151: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 151: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 151: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 151: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 152: -23 i1 != *
// ***********************
void integer_result_postfix_expression_test152 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 152: -23 i1 !=\n");
  printf ("Test 152: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 152: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 152: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 152: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 152: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 152: -23 i1 == *
// ***********************
void integer_result_postfix_expression_test153 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", TRUE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 153: -23 i1 ==\n");
  printf ("Test 153: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 153: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 153: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 153: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 153: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 154: i1 TRUE + *
// ************************
void integer_result_postfix_expression_test154 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "124");
  printf ("Test 154: i1 TRUE +\n");
  printf ("Test 154: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 154: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 154: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 154: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 154: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 155: i1 TRUE - *
// ***********************
void integer_result_postfix_expression_test155 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "122");
  printf ("Test 155: i1 TRUE -\n");
  printf ("Test 155: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 155: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 155: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 155: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 155: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 156: i1 TRUE * *
// ***********************
void integer_result_postfix_expression_test156 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 156: i1 TRUE *\n");
  printf ("Test 156: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 156: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 156: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 156: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 156: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 157: i1 TRUE / *
// ***********************
void integer_result_postfix_expression_test157 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 157: i1 TRUE /\n");
  printf ("Test 157: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 157: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 157: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 157: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 157: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 158: i1 TRUE % *
// ***********************
void integer_result_postfix_expression_test158 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 158: i1 TRUE %%\n");
  printf ("Test 158: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 158: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 158: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 158: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 158: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *************************
// * Test 159: i1 TRUE AND *
// *************************
void integer_result_postfix_expression_test159 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 159: i1 TRUE AND\n");
  printf ("Test 159: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 159: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 159: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 159: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 159: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 160: i1 TRUE OR *
// ************************
void integer_result_postfix_expression_test160 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 160: i1 TRUE OR\n");
  printf ("Test 160: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 160: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 160: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 160: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 160: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *************************
// * Test 161: i1 TRUE XOR *
// *************************
void integer_result_postfix_expression_test161 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 161: i1 TRUE XOR\n");
  printf ("Test 161: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 161: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 161: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 161: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 161: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ************************
// * Test 162: i1 TRUE >= *
// ************************
void integer_result_postfix_expression_test162 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 162: i1 TRUE >=\n");
  printf ("Test 162: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 162: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 162: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 162: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 162: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 163: i1 TRUE > *
// ***********************
void integer_result_postfix_expression_test163 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 163: i1 TRUE >\n");
  printf ("Test 163: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 163: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 163: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 163: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 163: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 164: i1 TRUE <= *
// ************************
void integer_result_postfix_expression_test164 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 164: i1 TRUE <=\n");
  printf ("Test 164: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 164: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 164: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 164: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 164: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 165: i1 TRUE < *
// ***********************
void integer_result_postfix_expression_test165 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 165: i1 TRUE <\n");
  printf ("Test 165: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 165: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 165: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 165: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 165: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ************************
// * Test 166: i1 TRUE != *
// ************************
void integer_result_postfix_expression_test166 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 166: i1 TRUE !=\n");
  printf ("Test 166: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 166: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 166: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 166: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 166: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ************************
// * Test 167: i1 TRUE == *
// ************************
void integer_result_postfix_expression_test167 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 167: i1 TRUE ==\n");
  printf ("Test 167: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 167: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 167: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 167: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 167: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ***********************
// * Test 168: TRUE i1 + *
// ***********************
void integer_result_postfix_expression_test168 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "124");
  printf ("Test 168: TRUE i1 +\n");
  printf ("Test 168: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 168: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 168: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 168: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 168: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ***********************
// * Test 169: TRUE i1 - *
// ***********************
void integer_result_postfix_expression_test169 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-122");
  printf ("Test 169: TRUE i1 -\n");
  printf ("Test 169: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 169: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 169: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 169: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 169: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ***********************
// * Test 170: TRUE i1 * *
// ***********************
void integer_result_postfix_expression_test170 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 170: TRUE i1 *\n");
  printf ("Test 170: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 170: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 170: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 170: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 170: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ***********************
// * Test 171: TRUE i1 / *
// ***********************
void integer_result_postfix_expression_test171 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 171: TRUE i1 /\n");
  printf ("Test 171: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 171: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 171: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 171: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 171: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ***********************
// * Test 172: TRUE i1 % *
// ***********************
void integer_result_postfix_expression_test172 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 172: TRUE i1 %%\n");
  printf ("Test 172: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 172: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 172: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 172: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 172: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *************************
// * Test 173: TRUE i1 AND *
// *************************
void integer_result_postfix_expression_test173 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 173: TRUE i1 AND\n");
  printf ("Test 173: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 173: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 173: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 173: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 173: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ************************
// * Test 174: TRUE i1 OR *
// ************************
void integer_result_postfix_expression_test174 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 174: TRUE i1 OR\n");
  printf ("Test 174: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 174: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 174: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 174: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 174: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *************************
// * Test 175: TRUE i1 XOR *
// *************************
void integer_result_postfix_expression_test175 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 175: TRUE i1 XOR\n");
  printf ("Test 175: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 175: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 175: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 175: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 175: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// ************************
// * Test 176: TRUE i1 >= *
// ************************
void integer_result_postfix_expression_test176 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 176: TRUE i1 >=\n");
  printf ("Test 176: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 176: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 176: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 176: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 176: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 177: TRUE i1 > *
// ***********************
void integer_result_postfix_expression_test177 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 177: TRUE i1 >\n");
  printf ("Test 177: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 177: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 177: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 177: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 177: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 178: TRUE i1 <= *
// ************************
void integer_result_postfix_expression_test178 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 178: TRUE i1 <=\n");
  printf ("Test 178: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 178: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 178: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 178: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 178: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ***********************
// * Test 179: TRUE i1 < *
// ***********************
void integer_result_postfix_expression_test179 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 179: TRUE i1 <\n");
  printf ("Test 179: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 179: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 179: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 179: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 179: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 180: TRUE i1 != *
// ************************
void integer_result_postfix_expression_test180 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 180: TRUE i1 !=\n");
  printf ("Test 180: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 180: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 180: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 180: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 180: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ************************
// * Test 181: TRUE i1 == *
// ************************
void integer_result_postfix_expression_test181 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 181: TRUE i1 ==\n");
  printf ("Test 181: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 181: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 181: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 181: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 181: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



// ****************************
// * Test 182: i1 54321.999 + *
// ****************************
void integer_result_postfix_expression_test182 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54444");
  printf ("Test 182: i1 54321.999 +\n");
  printf ("Test 182: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 182: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 182: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 182: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 182: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 183: i1 54321.999 - *
// ****************************
void integer_result_postfix_expression_test183 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-54198");
  printf ("Test 183: i1 54321.999 -\n");
  printf ("Test 183: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 183: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 183: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 183: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 183: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 184: i1 54321.999 * *
// ****************************
void integer_result_postfix_expression_test184 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "6681605");
  printf ("Test 184: i1 54321.999 *\n");
  printf ("Test 184: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 184: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 184: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 184: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 184: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 185: i1 54321.999 / *
// ****************************
void integer_result_postfix_expression_test185 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 185: i1 54321.999 /\n");
  printf ("Test 185: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 185: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 185: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 185: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 185: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 186: i1 54321.999 % *
// ****************************
void integer_result_postfix_expression_test186 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 186: i1 54321.999 %%\n");
  printf ("Test 186: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 186: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 186: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 186: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 186: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// ******************************
// * Test 187: i1 54321.999 AND *
// ******************************
void integer_result_postfix_expression_test187 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 187: i1 54321.999 AND\n");
  printf ("Test 187: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 187: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 187: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 187: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 187: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *****************************
// * Test 188: i1 54321.999 OR *
// *****************************
void integer_result_postfix_expression_test188 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 188: i1 54321.999 OR\n");
  printf ("Test 188: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 188: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 188: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 188: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 188: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ******************************
// * Test 189: i1 54321.999 XOR *
// ******************************
void integer_result_postfix_expression_test189 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 189: i1 54321.999 XOR\n");
  printf ("Test 189: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 189: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 189: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 189: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 189: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// *****************************
// * Test 190: i1 54321.999 >= *
// *****************************
void integer_result_postfix_expression_test190 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 190: i1 54321.999 >=\n");
  printf ("Test 190: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 190: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 190: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 190: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 190: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// ****************************
// * Test 191: i1 54321.999 > *
// ****************************
void integer_result_postfix_expression_test191 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 191: i1 54321.999 >\n");
  printf ("Test 191: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 191: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 191: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 191: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 191: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *****************************
// * Test 192: i1 54321.999 <= *
// *****************************
void integer_result_postfix_expression_test192 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 192: i1 54321.999 <=\n");
  printf ("Test 192: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 192: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 192: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 192: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 192: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// ****************************
// * Test 193: i1 54321.999 < *
// ****************************
void integer_result_postfix_expression_test193 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 193: i1 54321.999 <=\n");
  printf ("Test 193: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 193: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 193: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 193: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 193: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *****************************
// * Test 194: i1 54321.999 != *
// *****************************
void integer_result_postfix_expression_test194 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 194: i1 54321.999 !=\n");
  printf ("Test 194: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 194: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 194: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 194: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 194: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *****************************
// * Test 195: i1 54321.999 == *
// *****************************
void integer_result_postfix_expression_test195 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 195: i1 54321.999 ==\n");
  printf ("Test 195: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 195: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 195: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 195: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 195: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// ****************************
// * Test 196: 54321.999 i1 + *
// ****************************
void integer_result_postfix_expression_test196 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54444");
  printf ("Test 196: 54321.999 i1 +\n");
  printf ("Test 196: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 196: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 196: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 196: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 196: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 197: 54321.999 i1 - *
// ****************************
void integer_result_postfix_expression_test197 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "54198");
  printf ("Test 197: 54321.999 i1 -\n");
  printf ("Test 197: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 197: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 197: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 197: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 197: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// ****************************
// * Test 198: 54321.999 i1 * *
// ****************************
void integer_result_postfix_expression_test198 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "6681605");
  printf ("Test 198: 54321.999 i1 *\n");
  printf ("Test 198: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 198: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 198: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 198: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 198: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 199: 54321.999 i1 / *
// ****************************
void integer_result_postfix_expression_test199 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "441");
  printf ("Test 199: 54321.999 i1 /\n");
  printf ("Test 199: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 199: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 199: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 199: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 199: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 200: 54321.999 i1 % *
// ****************************
void integer_result_postfix_expression_test200 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "78");
  printf ("Test 200: 54321.999 i1 %%\n");
  printf ("Test 200: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 200: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 200: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 200: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 200: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ******************************
// * Test 201: 54321.999 i1 AND *
// ******************************
void integer_result_postfix_expression_test201 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 201: 54321.999 i1 AND\n");
  printf ("Test 201: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 201: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 201: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 201: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 201: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// *****************************
// * Test 202: 54321.999 i1 OR *
// *****************************
void integer_result_postfix_expression_test202 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 202: 54321.999 i1 OR\n");
  printf ("Test 202: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 202: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 202: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 202: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 202: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// ******************************
// * Test 203: 54321.999 i1 XOR *
// ******************************
void integer_result_postfix_expression_test203 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 203: 54321.999 i1 XOR\n");
  printf ("Test 203: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 203: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 203: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 203: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 203: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// *****************************
// * Test 204: 54321.999 i1 >= *
// *****************************
void integer_result_postfix_expression_test204 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 204: 54321.999 i1 >=\n");
  printf ("Test 204: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 204: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 204: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 204: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 204: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 205: 54321.999 i1 > *
// ****************************
void integer_result_postfix_expression_test205 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 205: 54321.999 i1 >\n");
  printf ("Test 205: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 205: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 205: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 205: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 205: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *****************************
// * Test 206: 54321.999 i1 <= *
// *****************************
void integer_result_postfix_expression_test206 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 206: 54321.999 i1 <=\n");
  printf ("Test 206: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 206: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 206: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 206: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 206: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// ****************************
// * Test 207: 54321.999 i1 < *
// ****************************
void integer_result_postfix_expression_test207 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 207: 54321.999 i1 <\n");
  printf ("Test 207: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 207: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 207: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 207: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 207: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *****************************
// * Test 208: 54321.999 i1 != *
// *****************************
void integer_result_postfix_expression_test208 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 208: 54321.999 i1 !=\n");
  printf ("Test 208: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 208: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 208: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 208: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 208: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




// *****************************
// * Test 209: 54321.999 i1 == *
// *****************************
void integer_result_postfix_expression_test209 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 209: 54321.999 i1 ==\n");
  printf ("Test 209: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 209: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 209: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 209: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 209: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}





// **********************
// * Test 210: f1 -23 + *
// **********************
void integer_result_postfix_expression_test210 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54298");
  printf ("Test 210: f1 -23 +\n");
  printf ("Test 210: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 210: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 210: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 210: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 210: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 211: f1 -23 - *
// **********************
void integer_result_postfix_expression_test211 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "54344");
  printf ("Test 211: f1 -23 -\n");
  printf ("Test 211: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 211: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 211: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 211: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 211: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 212: f1 -23 * *
// **********************
void integer_result_postfix_expression_test212 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "-1249405");
  printf ("Test 212: f1 -23 *\n");
  printf ("Test 212: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 212: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 212: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 212: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 212: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 213: f1 -23 / *
// **********************
void integer_result_postfix_expression_test213 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "-2361");
  printf ("Test 213: f1 -23 /\n");
  printf ("Test 213: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 213: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 213: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 213: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 213: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// **********************
// * Test 214: f1 -23 % *
// **********************
void integer_result_postfix_expression_test214 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "18");
  printf ("Test 214: f1 -23 %%\n");
  printf ("Test 214: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 214: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 214: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 214: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 214: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 215: f1 -23 AND *
// ************************
void integer_result_postfix_expression_test215 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 215: f1 -23 AND\n");
  printf ("Test 215: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 215: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 215: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 215: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 215: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 216: f1 -23 OR *
// ***********************
void integer_result_postfix_expression_test216 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 216: f1 -23 OR\n");
  printf ("Test 216: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 216: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 216: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 216: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 216: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 217: f1 -23 XOR *
// ************************
void integer_result_postfix_expression_test217 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 217: f1 -23 XOR\n");
  printf ("Test 217: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 217: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 217: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 217: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 217: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 218: f1 -23 >= *
// ***********************
void integer_result_postfix_expression_test218 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 218: f1 -23 >=\n");
  printf ("Test 218: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 218: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 218: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 218: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 218: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 219: f1 -23 > *
// **********************
void integer_result_postfix_expression_test219 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 219: f1 -23 >\n");
  printf ("Test 219: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 219: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 219: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 219: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 219: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 220: f1 -23 <= *
// ***********************
void integer_result_postfix_expression_test220 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 220: f1 -23 <=\n");
  printf ("Test 220: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 220: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 220: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 220: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 220: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 221: f1 -23 < *
// **********************
void integer_result_postfix_expression_test221 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 221: f1 -23 <\n");
  printf ("Test 221: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 221: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 221: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 221: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 221: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 222: f1 -23 != *
// ***********************
void integer_result_postfix_expression_test222 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 222: f1 -23 !=\n");
  printf ("Test 222: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 222: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 222: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 222: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 222: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 223: f1 -23 == *
// ***********************
void integer_result_postfix_expression_test223 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 223: f1 -23 ==\n");
  printf ("Test 223: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 223: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 223: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 223: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 223: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 224: -23 f1 + *
// **********************
void integer_result_postfix_expression_test224 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54298");
  printf ("Test 224: -23 f1 +\n");
  printf ("Test 224: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 224: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 224: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 224: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 224: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// **********************
// * Test 225: -23 f1 - *
// **********************
void integer_result_postfix_expression_test225 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-54344");
  printf ("Test 225: -23 f1 -\n");
  printf ("Test 225: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 225: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 225: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 225: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 225: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 226: -23 f1 * *
// **********************
void integer_result_postfix_expression_test226 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "-1249405");
  printf ("Test 226: -23 f1 *\n");
  printf ("Test 226: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 226: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 226: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 226: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 226: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 227: -23 f1 / *
// **********************
void integer_result_postfix_expression_test227 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 227: -23 f1 /\n");
  printf ("Test 227: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 227: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 227: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 227: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 227: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 228: -23 f1 % *
// **********************
void integer_result_postfix_expression_test228 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "-23");
  printf ("Test 228: -23 f1 %%\n");
  printf ("Test 228: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 228: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 228: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 228: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 228: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 229: -23 f1 AND *
// ************************
void integer_result_postfix_expression_test229 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 229: -23 f1 AND\n");
  printf ("Test 229: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 229: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 229: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 229: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 229: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// ***********************
// * Test 230: -23 f1 OR *
// ***********************
void integer_result_postfix_expression_test230 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 230: -23 f1 OR\n");
  printf ("Test 230: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 230: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 230: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 230: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 230: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// ************************
// * Test 231: -23 f1 XOR *
// ************************
void integer_result_postfix_expression_test231 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 231: -23 f1 XOR\n");
  printf ("Test 231: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 231: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 231: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 231: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 231: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 232: -23 f1 >= *
// ***********************
void integer_result_postfix_expression_test232 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 232: -23 f1 >=\n");
  printf ("Test 232: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 232: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 232: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 232: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 232: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 233: -23 f1 > *
// **********************
void integer_result_postfix_expression_test233 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 233: -23 f1 >\n");
  printf ("Test 233: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 233: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 233: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 233: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 233: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 234: -23 f1 <= *
// ***********************
void integer_result_postfix_expression_test234 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 234: -23 f1 <=\n");
  printf ("Test 234: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 234: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 234: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 234: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 234: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 235: -23 f1 < *
// **********************
void integer_result_postfix_expression_test235 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 235: -23 f1 <\n");
  printf ("Test 235: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 235: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 235: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 235: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 235: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 236: -23 f1 != *
// ***********************
void integer_result_postfix_expression_test236 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 236: -23 f1 !=\n");
  printf ("Test 236: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 236: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 236: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 236: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 236: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 237: -23 f1 == *
// ***********************
void integer_result_postfix_expression_test237 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "54321.999");
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 237: -23 f1 ==\n");
  printf ("Test 237: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 237: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 237: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 237: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 237: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// ****************************
// * Test 238: f1 54321.999 + *
// ****************************
void integer_result_postfix_expression_test238 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54322");
  printf ("Test 238: f1 54321.999 +\n");
  printf ("Test 238: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 238: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 238: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 238: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 238: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 239: f1 54321.999 - *
// ****************************
void integer_result_postfix_expression_test239 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-54321");
  printf ("Test 239: f1 54321.999 -\n");
  printf ("Test 239: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 239: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 239: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 239: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 239: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 240: f1 54321.999 * *
// ****************************
void integer_result_postfix_expression_test240 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "54");
  printf ("Test 240: f1 54321.999 *\n");
  printf ("Test 240: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 240: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 240: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 240: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 240: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 241: f1 54321.999 / *
// ****************************
void integer_result_postfix_expression_test241 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 241: f1 54321.999 /\n");
  printf ("Test 241: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 241: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 241: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 241: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 241: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 242: f1 54321.999 % *
// ****************************
void integer_result_postfix_expression_test242 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 242: f1 54321.999 %%\n");
  printf ("Test 242: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 242: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 242: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 242: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 242: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ******************************
// * Test 243: f1 54321.999 AND *
// ******************************
void integer_result_postfix_expression_test243 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 243: f1 54321.999 AND\n");
  printf ("Test 243: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 243: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 243: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 243: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 243: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// *****************************
// * Test 244: f1 54321.999 OR *
// *****************************
void integer_result_postfix_expression_test244 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 244: f1 54321.999 OR\n");
  printf ("Test 244: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 244: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 244: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 244: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 244: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ******************************
// * Test 245: f1 54321.999 XOR *
// ******************************
void integer_result_postfix_expression_test245 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 245: f1 54321.999 XOR\n");
  printf ("Test 245: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 245: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 245: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 245: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 245: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *****************************
// * Test 246: f1 54321.999 >= *
// *****************************
void integer_result_postfix_expression_test246 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 246: f1 54321.999 >=\n");
  printf ("Test 246: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 246: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 246: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 246: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 246: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 247: f1 54321.999 > *
// ****************************
void integer_result_postfix_expression_test247 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 247: f1 54321.999 >\n");
  printf ("Test 247: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 247: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 247: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 247: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 247: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *****************************
// * Test 248: f1 54321.999 <= *
// *****************************
void integer_result_postfix_expression_test248 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 248: f1 54321.999 <=\n");
  printf ("Test 248: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 248: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 248: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 248: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 248: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 249: f1 54321.999 < *
// ****************************
void integer_result_postfix_expression_test249 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 249: f1 54321.999 <\n");
  printf ("Test 249: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 249: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 249: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 249: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 249: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *****************************
// * Test 250: f1 54321.999 != *
// *****************************
void integer_result_postfix_expression_test250 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 250: f1 54321.999 !=\n");
  printf ("Test 250: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 250: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 250: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 250: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 250: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *****************************
// * Test 251: f1 54321.999 == *
// *****************************
void integer_result_postfix_expression_test251 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 251: f1 54321.999 ==\n");
  printf ("Test 251: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 251: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 251: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 251: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 251: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 252: 54321.999 f1 + *
// ****************************
void integer_result_postfix_expression_test252 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54322");
  printf ("Test 252: 54321.999 f1 +\n");
  printf ("Test 252: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 252: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 252: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 252: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 252: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 253: 54321.999 f1 - *
// ****************************
void integer_result_postfix_expression_test253 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 253: 54321.999 f1 -\n");
  printf ("Test 253: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 253: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 253: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 253: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 253: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 254: 54321.999 f1 * *
// ****************************
void integer_result_postfix_expression_test254 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "54");
  printf ("Test 254: 54321.999 f1 *\n");
  printf ("Test 254: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 254: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 254: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 254: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 254: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 255: 54321.999 f1 / *
// ****************************
void integer_result_postfix_expression_test255 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "54321999");
  printf ("Test 255: 54321.999 f1 /\n");
  printf ("Test 255: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 255: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 255: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 255: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 255: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 256: 54321.999 f1 % *
// ****************************
void integer_result_postfix_expression_test256 (void)
{
  runtime_expression_node *expression;
  psint *result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  printf ("Test 256: 54321.999 f1 %%\n");
  printf ("Test 256: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 256: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (result->sign == undefined)
    {
      printf ("Test 256: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 256: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 256: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ******************************
// * Test 257: 54321.999 f1 AND *
// ******************************
void integer_result_postfix_expression_test257 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 257: 54321.999 f1 AND\n");
  printf ("Test 257: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 257: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 257: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 257: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 257: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// *****************************
// * Test 258: 54321.999 f1 OR *
// *****************************
void integer_result_postfix_expression_test258 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 258: 54321.999 f1 OR\n");
  printf ("Test 258: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 258: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 258: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 258: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 258: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ******************************
// * Test 259: 54321.999 f1 XOR *
// ******************************
void integer_result_postfix_expression_test259 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 259: 54321.999 f1 XOR\n");
  printf ("Test 259: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 259: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 259: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 259: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 259: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *****************************
// * Test 260: 54321.999 f1 >= *
// *****************************
void integer_result_postfix_expression_test260 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 260: 54321.999 f1 >=\n");
  printf ("Test 260: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 260: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 260: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 260: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 260: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ****************************
// * Test 261: 54321.999 f1 > *
// ****************************
void integer_result_postfix_expression_test261 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 261: 54321.999 f1 >\n");
  printf ("Test 261: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 261: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 261: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 261: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 261: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *****************************
// * Test 262: 54321.999 f1 <= *
// *****************************
void integer_result_postfix_expression_test262 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 262: 54321.999 f1 <=\n");
  printf ("Test 262: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 262: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 262: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 262: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 262: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// ****************************
// * Test 263: 54321.999 f1 < *
// ****************************
void integer_result_postfix_expression_test263 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 263: 54321.999 f1 <\n");
  printf ("Test 263: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 263: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 263: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 263: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 263: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *****************************
// * Test 264: 54321.999 f1 != *
// *****************************
void integer_result_postfix_expression_test264 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 264: 54321.999 f1 !=\n");
  printf ("Test 264: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 264: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 264: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 264: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 264: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *****************************
// * Test 265: 54321.999 f1 == *
// *****************************
void integer_result_postfix_expression_test265 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 265: 54321.999 f1 ==\n");
  printf ("Test 265: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 265: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 265: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 265: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 265: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// ***********************
// * Test 266: f1 TRUE + *
// ***********************
void integer_result_postfix_expression_test266 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 266: f1 TRUE +\n");
  printf ("Test 266: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 266: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 266: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 266: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 266: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 267: f1 TRUE - *
// ***********************
void integer_result_postfix_expression_test267 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 267: f1 TRUE -\n");
  printf ("Test 267: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 267: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 267: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 267: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 267: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// ***********************
// * Test 268: f1 TRUE * *
// ***********************
void integer_result_postfix_expression_test268 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 268: f1 TRUE *\n");
  printf ("Test 268: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 268: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 268: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 268: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 268: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 269: f1 TRUE / *
// ***********************
void integer_result_postfix_expression_test269 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 269: f1 TRUE /\n");
  printf ("Test 269: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 269: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 269: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 269: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 269: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// ***********************
// * Test 270: f1 TRUE % *
// ***********************
void integer_result_postfix_expression_test270 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 270: f1 TRUE %%\n");
  printf ("Test 270: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 270: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 270: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 270: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 270: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




  
// *************************
// * Test 271: f1 TRUE AND *
// *************************
void integer_result_postfix_expression_test271 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 271: f1 TRUE AND\n");
  printf ("Test 271: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 271: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 271: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 271: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 271: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



  
// ************************
// * Test 272: f1 TRUE OR *
// ************************
void integer_result_postfix_expression_test272 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 272: f1 TRUE OR\n");
  printf ("Test 272: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 272: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 272: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 272: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 272: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *************************
// * Test 273: f1 TRUE XOR *
// *************************
void integer_result_postfix_expression_test273 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 273: f1 TRUE XOR\n");
  printf ("Test 273: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 273: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 273: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 273: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 273: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 274: f1 TRUE >= *
// ************************
void integer_result_postfix_expression_test274 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 274: f1 TRUE >=\n");
  printf ("Test 274: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 274: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 274: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 274: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 274: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 275: f1 TRUE > *
// ***********************
void integer_result_postfix_expression_test275 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 275: f1 TRUE >\n");
  printf ("Test 275: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 275: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 275: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 275: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 275: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 276: f1 TRUE <= *
// ************************
void integer_result_postfix_expression_test276 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 276: f1 TRUE <=\n");
  printf ("Test 276: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 276: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 276: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 276: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 276: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 277: f1 TRUE < *
// ***********************
void integer_result_postfix_expression_test277 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 277: f1 TRUE <\n");
  printf ("Test 277: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 277: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 277: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 277: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 277: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 278: f1 TRUE != *
// ************************
void integer_result_postfix_expression_test278 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 278: f1 TRUE !=\n");
  printf ("Test 278: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 278: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 278: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 278: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 278: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 279: f1 TRUE == *
// ************************
void integer_result_postfix_expression_test279 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 279: f1 TRUE ==\n");
  printf ("Test 279: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 279: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 279: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 279: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 279: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// ***********************
// * Test 280: TRUE f1 + *
// ***********************
void integer_result_postfix_expression_test280 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 280: TRUE f1 +\n");
  printf ("Test 280: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 280: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 280: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 280: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 280: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 281: TRUE f1 - *
// ***********************
void integer_result_postfix_expression_test281 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 281: TRUE f1 -\n");
  printf ("Test 281: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 281: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 281: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 281: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 281: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 282: TRUE f1 * *
// ***********************
void integer_result_postfix_expression_test282 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 282: TRUE f1 *\n");
  printf ("Test 282: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 282: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 282: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 282: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 282: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// ***********************
// * Test 283: TRUE f1 / *
// ***********************
void integer_result_postfix_expression_test283 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "1000");
  printf ("Test 283: TRUE f1 /\n");
  printf ("Test 283: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 283: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 283: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 283: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 283: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 284: TRUE f1 % *
// ***********************
void integer_result_postfix_expression_test284 (void)
{
  runtime_expression_node *expression;
  psint *result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  printf ("Test 284: TRUE f1 %%\n");
  printf ("Test 284: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 284: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (result->sign == undefined)
    {
      printf ("Test 284: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 284: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 284: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// *************************
// * Test 285: TRUE f1 AND *
// *************************
void integer_result_postfix_expression_test285 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 285: TRUE f1 AND\n");
  printf ("Test 285: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 285: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 285: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 285: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 285: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// ************************
// * Test 286: TRUE f1 OR *
// ************************
void integer_result_postfix_expression_test286 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 286: TRUE f1 OR\n");
  printf ("Test 286: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 286: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 286: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 286: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 286: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *************************
// * Test 287: TRUE f1 XOR *
// *************************
void integer_result_postfix_expression_test287 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 287: TRUE f1 XOR\n");
  printf ("Test 287: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 287: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 287: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 287: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 287: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 288: TRUE f1 >= *
// ************************
void integer_result_postfix_expression_test288 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 288: TRUE f1 >=\n");
  printf ("Test 288: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 288: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 288: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 288: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 288: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 289: TRUE f1 > *
// ***********************
void integer_result_postfix_expression_test289 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 289: TRUE f1 >\n");
  printf ("Test 289: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 289: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 289: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 289: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 289: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 290: TRUE f1 <= *
// ************************
void integer_result_postfix_expression_test290 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 290: TRUE f1 <=\n");
  printf ("Test 290: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 290: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 290: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 290: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 290: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 291: TRUE f1 < *
// ***********************
void integer_result_postfix_expression_test291 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 291: TRUE f1 <\n");
  printf ("Test 291: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 291: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 291: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 291: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 291: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 292: TRUE f1 != *
// ************************
void integer_result_postfix_expression_test292 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 292: TRUE f1 !=\n");
  printf ("Test 292: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 292: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 292: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 292: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 292: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ************************
// * Test 293: TRUE f1 == *
// ************************
void integer_result_postfix_expression_test293 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "0.001");
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 293: TRUE f1 ==\n");
  printf ("Test 293: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 293: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 293: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 293: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 293: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// ****************************
// * Test 294: b1 54321.999 + *
// ****************************
void integer_result_postfix_expression_test294 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54322");
  printf ("Test 294: b1 54321.999 +\n");
  printf ("Test 294: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 294: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 294: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 294: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 294: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 295: b1 54321.999 - *
// ****************************
void integer_result_postfix_expression_test295 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-54320");
  printf ("Test 295: b1 54321.999 -\n");
  printf ("Test 295: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 295: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 295: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 295: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 295: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 296: b1 54321.999 * *
// ****************************
void integer_result_postfix_expression_test296 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 296: b1 54321.999 *\n");
  printf ("Test 296: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 296: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 296: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 296: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 296: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 297: b1 54321.999 / *
// ****************************
void integer_result_postfix_expression_test297 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 297: b1 54321.999 /\n");
  printf ("Test 297: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 297: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 297: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 297: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 297: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 298: b1 54321.999 % *
// ****************************
void integer_result_postfix_expression_test298 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 298: b1 54321.999 %%\n");
  printf ("Test 298: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 298: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 298: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 298: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 298: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ******************************
// * Test 299: b1 54321.999 AND *
// ******************************
void integer_result_postfix_expression_test299 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 299: b1 54321.999 AND\n");
  printf ("Test 299: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 299: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 299: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 299: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 299: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 300: b1 54321.999 OR *
// *****************************
void integer_result_postfix_expression_test300 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 300: b1 54321.999 OR\n");
  printf ("Test 300: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 300: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 300: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 300: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 300: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ******************************
// * Test 301: b1 54321.999 XOR *
// ******************************
void integer_result_postfix_expression_test301 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 301: b1 54321.999 XOR\n");
  printf ("Test 301: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 301: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 301: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 301: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 301: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 302: b1 54321.999 >= *
// *****************************
void integer_result_postfix_expression_test302 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 302: b1 54321.999 >=\n");
  printf ("Test 302: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 302: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 302: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 302: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 302: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// ****************************
// * Test 303: b1 54321.999 > *
// ****************************
void integer_result_postfix_expression_test303 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 303: b1 54321.999 >\n");
  printf ("Test 303: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 303: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 303: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 303: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 303: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 304: b1 54321.999 <= *
// *****************************
void integer_result_postfix_expression_test304 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 304: b1 54321.999 <=\n");
  printf ("Test 304: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 304: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 304: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 304: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 304: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 305: b1 54321.999 < *
// ****************************
void integer_result_postfix_expression_test305 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 305: b1 54321.999 <\n");
  printf ("Test 305: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 305: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 305: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 305: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 305: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 306: b1 54321.999 != *
// *****************************
void integer_result_postfix_expression_test306 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 306: b1 54321.999 !=\n");
  printf ("Test 306: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 306: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 306: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 306: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 306: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 307: b1 54321.999 == *
// *****************************
void integer_result_postfix_expression_test307 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 307: b1 54321.999 ==\n");
  printf ("Test 307: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 307: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 307: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 307: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 307: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// ****************************
// * Test 308: 54321.999 b1 + *
// ****************************
void integer_result_postfix_expression_test308 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "54322");
  printf ("Test 308: 54321.999 b1 +\n");
  printf ("Test 308: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 308: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 308: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 308: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 308: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 309: 54321.999 b1 - *
// ****************************
void integer_result_postfix_expression_test309 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "54320");
  printf ("Test 309: 54321.999 b1 -\n");
  printf ("Test 309: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 309: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 309: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 309: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 309: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 310: 54321.999 b1 * *
// ****************************
void integer_result_postfix_expression_test310 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 310: 54321.999 b1 *\n");
  printf ("Test 310: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 310: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 310: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 310: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 310: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 311: 54321.999 b1 / *
// ****************************
void integer_result_postfix_expression_test311 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "54321");
  printf ("Test 311: 54321.999 b1 /\n");
  printf ("Test 311: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 311: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 311: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 311: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 311: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 312: 54321.999 b1 % *
// ****************************
void integer_result_postfix_expression_test312 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 312: 54321.999 b1 %%\n");
  printf ("Test 312: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 312: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 312: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 312: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 312: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ******************************
// * Test 313: 54321.999 b1 AND *
// ******************************
void integer_result_postfix_expression_test313 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 313: 54321.999 b1 AND\n");
  printf ("Test 313: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 313: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 313: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 313: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 313: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 314: 54321.999 b1 OR *
// *****************************
void integer_result_postfix_expression_test314 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 314: 54321.999 b1 OR\n");
  printf ("Test 314: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 314: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 314: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 314: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 314: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ******************************
// * Test 315: 54321.999 b1 XOR *
// ******************************
void integer_result_postfix_expression_test315 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 315: 54321.999 b1 XOR\n");
  printf ("Test 315: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 315: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 315: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 315: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 315: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 316: 54321.999 b1 >= *
// *****************************
void integer_result_postfix_expression_test316 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 316: 54321.999 b1 >=\n");
  printf ("Test 316: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 316: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 316: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 316: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 316: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 317: 54321.999 b1 > *
// ****************************
void integer_result_postfix_expression_test317 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 317: 54321.999 b1 >\n");
  printf ("Test 317: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 317: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 317: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 317: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 317: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 318: 54321.999 b1 <= *
// *****************************
void integer_result_postfix_expression_test318 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 318: 54321.999 b1 <=\n");
  printf ("Test 318: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 318: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 318: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 318: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 318: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ****************************
// * Test 319: 54321.999 b1 < *
// ****************************
void integer_result_postfix_expression_test319 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 319: 54321.999 b1 <\n");
  printf ("Test 319: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 319: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 319: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 319: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 319: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *****************************
// * Test 320: 54321.999 b1 != *
// *****************************
void integer_result_postfix_expression_test320 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 320: 54321.999 b1 !=\n");
  printf ("Test 320: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 320: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 320: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 320: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 320: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}



// *****************************
// * Test 321: 54321.999 b1 == *
// *****************************
void integer_result_postfix_expression_test321 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.999", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 321: 54321.999 b1 ==\n");
  printf ("Test 321: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 321: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 321: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 321: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 321: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 322: b1 -23 + *
// **********************
void integer_result_postfix_expression_test322 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "-22");
  printf ("Test 322: b1 -23 +\n");
  printf ("Test 322: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 322: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 322: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 322: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 322: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// **********************
// * Test 323: b1 -23 - *
// **********************
void integer_result_postfix_expression_test323 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "24");
  printf ("Test 323: b1 -23 -\n");
  printf ("Test 323: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 323: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 323: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 323: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 323: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 324: b1 -23 * *
// **********************
void integer_result_postfix_expression_test324 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "-23");
  printf ("Test 324: b1 -23 *\n");
  printf ("Test 324: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 324: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 324: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 324: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 324: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 325: b1 -23 / *
// **********************
void integer_result_postfix_expression_test325 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 325: b1 -23 /\n");
  printf ("Test 325: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 325: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 325: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 325: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 325: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// **********************
// * Test 326: b1 -23 % *
// **********************
void integer_result_postfix_expression_test326 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 326: b1 -23 %%\n");
  printf ("Test 326: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 326: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 326: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 326: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 326: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ************************
// * Test 327: b1 -23 AND *
// ************************
void integer_result_postfix_expression_test327 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 327: b1 -23 AND\n");
  printf ("Test 327: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 327: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 327: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 327: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 327: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 328: b1 -23 OR *
// ***********************
void integer_result_postfix_expression_test328 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 328: b1 -23 OR\n");
  printf ("Test 328: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 328: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 328: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 328: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 328: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ************************
// * Test 329: b1 -23 XOR *
// ************************
void integer_result_postfix_expression_test329 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 329: b1 -23 XOR\n");
  printf ("Test 329: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 329: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 329: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 329: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 329: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 330: b1 -23 >= *
// ***********************
void integer_result_postfix_expression_test330 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 330: b1 -23 >=\n");
  printf ("Test 330: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 330: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 330: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 330: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 330: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// **********************
// * Test 331: b1 -23 > *
// **********************
void integer_result_postfix_expression_test331 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 331: b1 -23 >\n");
  printf ("Test 331: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 331: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 331: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 331: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 331: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// ***********************
// * Test 332: b1 -23 <= *
// ***********************
void integer_result_postfix_expression_test332 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 332: b1 -23 <=\n");
  printf ("Test 332: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 332: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 332: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 332: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 332: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 333: b1 -23 < *
// **********************
void integer_result_postfix_expression_test333 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 333: b1 -23 <\n");
  printf ("Test 333: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 333: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 333: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 333: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 333: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 334: b1 -23 != *
// ***********************
void integer_result_postfix_expression_test334 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 334: b1 -23 !=\n");
  printf ("Test 334: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 334: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 334: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 334: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 334: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 335: b1 -23 == *
// ***********************
void integer_result_postfix_expression_test335 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 335: b1 -23 ==\n");
  printf ("Test 335: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 335: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 335: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 335: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 335: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 336: -23 b1 + *
// **********************
void integer_result_postfix_expression_test336 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "-22");
  printf ("Test 336: -23 b1 +\n");
  printf ("Test 336: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 336: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 336: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 336: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 336: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 337: -23 b1 - *
// **********************
void integer_result_postfix_expression_test337 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-24");
  printf ("Test 337: -23 b1 -\n");
  printf ("Test 337: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 337: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 337: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 337: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 337: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 338: -23 b1 * *
// **********************
void integer_result_postfix_expression_test338 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "-23");
  printf ("Test 338: -23 b1 *\n");
  printf ("Test 338: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 338: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 338: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 338: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 338: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// **********************
// * Test 339: -23 b1 / *
// **********************
void integer_result_postfix_expression_test339 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "-23");
  printf ("Test 339: -23 b1 /\n");
  printf ("Test 339: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 339: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 339: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 339: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 339: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// **********************
// * Test 340: -23 b1 % *
// **********************
void integer_result_postfix_expression_test340 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 340: -23 b1 %%\n");
  printf ("Test 340: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 340: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 340: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 340: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 340: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ************************
// * Test 341: -23 b1 AND *
// ************************
void integer_result_postfix_expression_test341 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 341: -23 b1 AND\n");
  printf ("Test 341: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 341: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 341: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 341: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 341: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 342: -23 b1 OR *
// ***********************
void integer_result_postfix_expression_test342 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 342: -23 b1 OR\n");
  printf ("Test 342: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 342: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 342: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 342: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 342: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ************************
// * Test 343: -23 b1 XOR *
// ************************
void integer_result_postfix_expression_test343 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 343: -23 b1 XOR\n");
  printf ("Test 343: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 343: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 343: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 343: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 343: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 344: -23 b1 >= *
// ***********************
void integer_result_postfix_expression_test344 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 344: -23 b1 >=\n");
  printf ("Test 344: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 344: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 344: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 344: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 344: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 345: -23 b1 > *
// **********************
void integer_result_postfix_expression_test345 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 345: -23 b1 >\n");
  printf ("Test 345: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 345: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 345: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 345: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 345: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 346: -23 b1 <= *
// ***********************
void integer_result_postfix_expression_test346 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 346: -23 b1 <=\n");
  printf ("Test 346: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 346: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 346: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 346: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 346: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 347: -23 b1 < *
// **********************
void integer_result_postfix_expression_test347 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 347: -23 b1 <\n");
  printf ("Test 347: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 347: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 347: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 347: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 347: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 348: -23 b1 != *
// ***********************
void integer_result_postfix_expression_test348 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 348: -23 b1 !=\n");
  printf ("Test 348: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 348: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 348: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 348: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 348: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 349: -23 b1 == *
// ***********************
void integer_result_postfix_expression_test349 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _constant_int, "-23", FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 349: -23 b1 ==\n");
  printf ("Test 349: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 349: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 349: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 349: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 349: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 350: i1 f1 + *
// *********************
void integer_result_postfix_expression_test350 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "246");
  printf ("Test 350: i1 f1 +\n");
  printf ("Test 350: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 350: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 350: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 350: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 350: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 351: i1 f1 - *
// *********************
void integer_result_postfix_expression_test351 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 351: i1 f1 -\n");
  printf ("Test 351: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 351: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 351: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 351: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 351: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 352: i1 f1 * *
// *********************
void integer_result_postfix_expression_test352 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "15185");
  printf ("Test 352: i1 f1 *\n");
  printf ("Test 352: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 352: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 352: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 352: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 352: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 353: i1 f1 / *
// *********************
void integer_result_postfix_expression_test353 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 353: i1 f1 /\n");
  printf ("Test 353: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 353: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 353: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 353: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 353: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}





// *********************
// * Test 354: i1 f1 % *
// *********************
void integer_result_postfix_expression_test354 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 354: i1 f1 %%\n");
  printf ("Test 354: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 354: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 354: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 354: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 354: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// ***********************
// * Test 355: i1 f1 AND *
// ***********************
void integer_result_postfix_expression_test355 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 355: i1 f1 and\n");
  printf ("Test 355: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 355: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 355: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 355: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 355: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 356: i1 f1 OR *
// ***********************
void integer_result_postfix_expression_test356 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 356: i1 f1 or\n");
  printf ("Test 356: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 356: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 356: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 356: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 356: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 357: i1 f1 XOR *
// ***********************
void integer_result_postfix_expression_test357 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 357: i1 f1 xor\n");
  printf ("Test 357: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 357: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 357: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 357: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 357: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 358: i1 f1 >= *
// **********************
void integer_result_postfix_expression_test358 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 358: i1 f1 >=\n");
  printf ("Test 358: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 358: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 358: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 358: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 358: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 359: i1 f1 > *
// *********************
void integer_result_postfix_expression_test359 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 359: i1 f1 >\n");
  printf ("Test 359: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 359: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 359: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 359: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 359: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 360: i1 f1 <= *
// **********************
void integer_result_postfix_expression_test360 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 360: i1 f1 <=\n");
  printf ("Test 360: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 360: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 360: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 360: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 360: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 361: i1 f1 < *
// *********************
void integer_result_postfix_expression_test361 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 361: i1 f1 <\n");
  printf ("Test 361: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 361: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 361: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 361: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 361: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// **********************
// * Test 362: i1 f1 != *
// **********************
void integer_result_postfix_expression_test362 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 362: i1 f1 !=\n");
  printf ("Test 362: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 362: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 362: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 362: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 362: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}



// **********************
// * Test 363: i1 f1 == *
// **********************
void integer_result_postfix_expression_test363 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 363: i1 f1 ==\n");
  printf ("Test 363: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 363: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 363: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 363: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 363: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 364: f1 i1 + *
// *********************
void integer_result_postfix_expression_test364 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "246");
  printf ("Test 364: f1 i1 +\n");
  printf ("Test 364: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 364: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 364: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 364: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 364: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 365: f1 i1 - *
// *********************
void integer_result_postfix_expression_test365 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 365: f1 i1 -\n");
  printf ("Test 365: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 365: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 365: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 365: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 365: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 366: f1 i1 * *
// *********************
void integer_result_postfix_expression_test366 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "15185");
  printf ("Test 366: f1 i1 *\n");
  printf ("Test 366: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 366: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 366: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 366: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 366: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 367: f1 i1 / *
// *********************
void integer_result_postfix_expression_test367 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 367: f1 i1 /\n");
  printf ("Test 367: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 367: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 367: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 367: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 367: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 368: f1 i1 % *
// *********************
void integer_result_postfix_expression_test368 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 368: f1 i1 %%\n");
  printf ("Test 368: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 368: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 368: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 368: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 368: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 369: f1 i1 AND *
// ***********************
void integer_result_postfix_expression_test369 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 369: f1 i1 AND\n");
  printf ("Test 369: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 369: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 369: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 369: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 369: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 370: f1 i1 OR *
// **********************
void integer_result_postfix_expression_test370 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 370: f1 i1 OR\n");
  printf ("Test 370: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 370: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 370: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 370: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 370: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// ***********************
// * Test 371: f1 i1 XOR *
// ***********************
void integer_result_postfix_expression_test371 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 371: f1 i1 XOR\n");
  printf ("Test 371: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 371: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 371: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 371: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 371: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 372: f1 i1 >= *
// **********************
void integer_result_postfix_expression_test372 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 372: f1 i1 >=\n");
  printf ("Test 372: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 372: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 372: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 372: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 372: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 373: f1 i1 > *
// *********************
void integer_result_postfix_expression_test373 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 373: f1 i1 >\n");
  printf ("Test 373: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 373: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 373: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 373: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 373: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 374: f1 i1 <= *
// **********************
void integer_result_postfix_expression_test374 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 374: f1 i1 <=\n");
  printf ("Test 374: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 374: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 374: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 374: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 374: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 375: f1 i1 < *
// *********************
void integer_result_postfix_expression_test375 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 375: f1 i1 <\n");
  printf ("Test 375: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 375: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 375: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 375: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 375: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 376: f1 i1 != *
// **********************
void integer_result_postfix_expression_test376 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 376: f1 i1 !=\n");
  printf ("Test 376: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 376: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 376: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 376: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 376: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// **********************
// * Test 377: f1 i1 == *
// **********************
void integer_result_postfix_expression_test377 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  psflt *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  f1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 377: f1 i1 ==\n");
  printf ("Test 377: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 377: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 377: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 377: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 377: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




// *********************
// * Test 378: i1 b1 + *
// *********************
void integer_result_postfix_expression_test378 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "124");
  printf ("Test 378: i1 b1 +\n");
  printf ("Test 378: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 378: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 378: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 378: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 378: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 379: i1 b1 - *
// *********************
void integer_result_postfix_expression_test379 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "122");
  printf ("Test 379: i1 b1 -\n");
  printf ("Test 379: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 379: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 379: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 379: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 379: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 380: i1 b1 * *
// *********************
void integer_result_postfix_expression_test380 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 380: i1 b1 *\n");
  printf ("Test 380: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 380: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 380: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 380: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 380: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 381: i1 b1 / *
// *********************
void integer_result_postfix_expression_test381 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 381: i1 b1 /\n");
  printf ("Test 381: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 381: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 381: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 381: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 381: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 382: i1 b1 % *
// *********************
void integer_result_postfix_expression_test382 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 382: i1 b1 %%\n");
  printf ("Test 382: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 382: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 382: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 382: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 382: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 383: i1 b1 AND *
// ***********************
void integer_result_postfix_expression_test383 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 383: i1 b1 AND\n");
  printf ("Test 383: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 383: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 383: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 383: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 383: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 384: i1 b1 OR *
// **********************
void integer_result_postfix_expression_test384 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 384: i1 b1 OR\n");
  printf ("Test 384: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 384: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 384: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 384: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 384: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 385: i1 b1 XOR *
// ***********************
void integer_result_postfix_expression_test385 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 385: i1 b1 XOR\n");
  printf ("Test 385: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 385: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 385: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 385: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 385: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// **********************
// * Test 386: i1 b1 >= *
// **********************
void integer_result_postfix_expression_test386 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 386: i1 b1 >=\n");
  printf ("Test 386: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 386: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 386: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 386: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 386: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 387: i1 b1 > *
// *********************
void integer_result_postfix_expression_test387 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 387: i1 b1 >\n");
  printf ("Test 387: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 387: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 387: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 387: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 387: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 388: i1 b1 <= *
// **********************
void integer_result_postfix_expression_test388 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 388: i1 b1 <=\n");
  printf ("Test 388: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 388: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 388: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 388: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 388: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 389: i1 b1 < *
// *********************
void integer_result_postfix_expression_test389 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 389: i1 b1 <\n");
  printf ("Test 389: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 389: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 389: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 389: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 389: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 390: i1 b1 != *
// **********************
void integer_result_postfix_expression_test390 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 390: i1 b1 !=\n");
  printf ("Test 390: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 390: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 390: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 390: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 390: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 391: i1 b1 == *
// **********************
void integer_result_postfix_expression_test391 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 391: i1 b1 ==\n");
  printf ("Test 391: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 391: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 391: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 391: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 391: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 392: b1 i1 + *
// *********************
void integer_result_postfix_expression_test392 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "124");
  printf ("Test 392: b1 i1 +\n");
  printf ("Test 392: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 392: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 392: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 392: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 392: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 393: b1 i1 - *
// *********************
void integer_result_postfix_expression_test393 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-122");
  printf ("Test 393: b1 i1 -\n");
  printf ("Test 393: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 393: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 393: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 393: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 393: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// *********************
// * Test 394: b1 i1 * *
// *********************
void integer_result_postfix_expression_test394 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 394: b1 i1 *\n");
  printf ("Test 394: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 394: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 394: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 394: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 394: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// *********************
// * Test 395: b1 i1 / *
// *********************
void integer_result_postfix_expression_test395 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 395: b1 i1 /\n");
  printf ("Test 395: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 395: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 395: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 395: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 395: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 396: b1 i1 % *
// *********************
void integer_result_postfix_expression_test396 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 396: b1 i1 %%\n");
  printf ("Test 396: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 396: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 396: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 396: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 396: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 397: b1 i1 AND *
// ***********************
void integer_result_postfix_expression_test397 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 397: b1 i1 AND\n");
  printf ("Test 397: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 397: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 397: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 397: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 397: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 398: b1 i1 OR *
// **********************
void integer_result_postfix_expression_test398 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 398: b1 i1 OR\n");
  printf ("Test 398: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 398: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 398: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 398: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 398: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 399: b1 i1 XOR *
// ***********************
void integer_result_postfix_expression_test399 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 399: b1 i1 XOR\n");
  printf ("Test 399: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 399: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 399: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 399: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 399: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// **********************
// * Test 400: b1 i1 >= *
// **********************
void integer_result_postfix_expression_test400 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 400: b1 i1 >=\n");
  printf ("Test 400: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 400: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 400: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 400: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 400: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 401: b1 i1 > *
// *********************
void integer_result_postfix_expression_test401 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 401: b1 i1 >\n");
  printf ("Test 401: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 401: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 401: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 401: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 401: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// **********************
// * Test 402: b1 i1 <= *
// **********************
void integer_result_postfix_expression_test402 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 402: b1 i1 <=\n");
  printf ("Test 402: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 402: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 402: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 402: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 402: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 403: b1 i1 < *
// *********************
void integer_result_postfix_expression_test403 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 403: b1 i1 <\n");
  printf ("Test 403: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 403: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 403: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 403: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 403: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 404: b1 i1 != *
// **********************
void integer_result_postfix_expression_test404 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 404: b1 i1 !=\n");
  printf ("Test 404: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 404: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 404: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 404: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 404: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 405: b1 i1 == *
// **********************
void integer_result_postfix_expression_test405 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result, *i1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 405: b1 i1 ==\n");
  printf ("Test 405: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 405: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 405: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 405: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 405: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 406: f1 b1 + *
// *********************
void integer_result_postfix_expression_test406 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "124");
  printf ("Test 406: f1 b1 +\n");
  printf ("Test 406: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 406: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 406: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 406: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 406: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 407: f1 b1 - *
// *********************
void integer_result_postfix_expression_test407 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "122");
  printf ("Test 407: f1 b1 -\n");
  printf ("Test 407: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 407: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 407: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 407: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 407: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 408: f1 b1 * *
// *********************
void integer_result_postfix_expression_test408 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 408: f1 b1 *\n");
  printf ("Test 408: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 408: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 408: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 408: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 408: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 409: f1 b1 / *
// *********************
void integer_result_postfix_expression_test409 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 409: f1 b1 /\n");
  printf ("Test 409: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 409: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 409: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 409: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 409: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 410: f1 b1 % *
// *********************
void integer_result_postfix_expression_test410 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 410: f1 b1 %%\n");
  printf ("Test 410: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 410: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 410: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 410: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 410: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 411: f1 b1 AND *
// ***********************
void integer_result_postfix_expression_test411 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 411: f1 b1 AND\n");
  printf ("Test 411: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 411: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 411: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 411: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 411: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 412: f1 b1 OR *
// **********************
void integer_result_postfix_expression_test412 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 412: f1 b1 OR\n");
  printf ("Test 412: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 412: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 412: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 412: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 412: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 413: f1 b1 XOR *
// ***********************
void integer_result_postfix_expression_test413 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 413: f1 b1 XOR\n");
  printf ("Test 413: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 413: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 413: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 413: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 413: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 414: f1 b1 >= *
// **********************
void integer_result_postfix_expression_test414 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 414: f1 b1 >=\n");
  printf ("Test 414: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 414: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 414: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 414: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 414: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// *********************
// * Test 415: f1 b1 > *
// *********************
void integer_result_postfix_expression_test415 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 415: f1 b1 >\n");
  printf ("Test 415: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 415: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 415: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 415: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 415: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
    b1 = NULL;
  }
  printf ("\n");
}




// **********************
// * Test 416: f1 b1 <= *
// **********************
void integer_result_postfix_expression_test416 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 416: f1 b1 <=\n");
  printf ("Test 416: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 416: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 416: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 416: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 416: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 417: f1 b1 < *
// *********************
void integer_result_postfix_expression_test417 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 417: f1 b1 <\n");
  printf ("Test 417: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 417: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 417: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 417: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 417: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 418: f1 b1 != *
// **********************
void integer_result_postfix_expression_test418 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 418: f1 b1 !=\n");
  printf ("Test 418: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 418: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 418: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 418: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 418: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 419: f1 b1 == *
// **********************
void integer_result_postfix_expression_test419 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 419: f1 b1 ==\n");
  printf ("Test 419: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 419: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 419: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 419: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 419: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 420: b1 f1 + *
// *********************
void integer_result_postfix_expression_test420 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  correct_result = packed_string_integer_set_value (correct_result, "124");
  printf ("Test 420: b1 f1 +\n");
  printf ("Test 420: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 420: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 420: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 420: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 420: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 421: b1 f1 - *
// *********************
void integer_result_postfix_expression_test421 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "-122");
  printf ("Test 421: b1 f1 -\n");
  printf ("Test 421: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 421: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 421: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 421: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 421: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 422: b1 f1 * *
// *********************
void integer_result_postfix_expression_test422 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "123");
  printf ("Test 422: b1 f1 *\n");
  printf ("Test 422: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 422: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 422: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 422: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 422: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 423: b1 f1 / *
// *********************
void integer_result_postfix_expression_test423 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 423: b1 f1 /\n");
  printf ("Test 423: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 423: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 423: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 423: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 423: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 424: b1 f1 % *
// *********************
void integer_result_postfix_expression_test424 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 424: b1 f1 %%\n");
  printf ("Test 424: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 424: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 424: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 424: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 424: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 425: b1 f1 AND *
// ***********************
void integer_result_postfix_expression_test425 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _and);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 425: b1 f1 AND\n");
  printf ("Test 425: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 425: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 425: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 425: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 425: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 426: b1 f1 OR *
// **********************
void integer_result_postfix_expression_test426 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _or);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 426: b1 f1 OR\n");
  printf ("Test 426: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 426: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 426: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 426: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 426: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ***********************
// * Test 427: b1 f1 XOR *
// ***********************
void integer_result_postfix_expression_test427 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _xor);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 427: b1 f1 XOR\n");
  printf ("Test 427: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 427: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 427: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 427: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 427: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 428: b1 f1 >= *
// **********************
void integer_result_postfix_expression_test428 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than_or_equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 428: b1 f1 >=\n");
  printf ("Test 428: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 428: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 428: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 428: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 428: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// *********************
// * Test 429: b1 f1 > *
// *********************
void integer_result_postfix_expression_test429 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _greater_than);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 429: b1 f1 >\n");
  printf ("Test 429: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 429: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 429: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 429: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 429: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 430: b1 f1 <= *
// **********************
void integer_result_postfix_expression_test430 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than_or_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 430: b1 f1 <=\n");
  printf ("Test 430: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 430: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 430: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 430: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 430: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}





// *********************
// * Test 431: b1 f1 < *
// *********************
void integer_result_postfix_expression_test431 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _less_than);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 431: b1 f1 <\n");
  printf ("Test 431: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 431: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 431: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 431: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 431: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 432: b1 f1 != *
// **********************
void integer_result_postfix_expression_test432 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _not_equal);
  correct_result = packed_string_integer_set_value (correct_result, "1");
  printf ("Test 432: b1 f1 !=\n");
  printf ("Test 432: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 432: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 432: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 432: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 432: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// **********************
// * Test 433: b1 f1 == *
// **********************
void integer_result_postfix_expression_test433 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psflt *f1;
  unsigned char *b1, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _equal);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 433: b1 f1 ==\n");
  printf ("Test 433: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 433: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 433: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 433: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 433: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




// ************************
// * Test 434: 12 2 3 * - *
// ************************
void integer_result_postfix_expression_test434 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "3", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_integer_set_value (correct_result, "6");
  printf ("Test 434: 12 2 3 * -\n");
  printf ("Test 434: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 434: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 434: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 434: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 434: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  printf ("\n");
}





// *************************************
// * Test 435: i1 200 * f1 - b1 + b1 % *
// *************************************
void integer_result_postfix_expression_test435 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *b1, *b2, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "200", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_integer_initialize_to_zero (correct_result);
  printf ("Test 435: i1 200 * f1 - b1 + b1 %%\n");
  printf ("Test 435: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 435: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 435: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 435: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 435: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




// ********************************************
// * Test 436: i1 f2 b1 i4 f4 f1 i2 * * * * + *
// ********************************************
void integer_result_postfix_expression_test436 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *b1, *b2, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f2, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i4, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f4, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i2, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _plus);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "437258851");
  printf ("Test 436: i1 f2 b1 i4 f4 f1 i2 * * * * + *\n");
  printf ("Test 436: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 436: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 436: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 436: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 436: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}





// Test 437: i1 i2 * 13 - f1 f4 / * 
void integer_result_postfix_expression_test437 (void)
{
  runtime_expression_node *expression;
  psint *result, *correct_result;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *b1, *b2, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i2, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "13", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f4, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_integer_set_value (correct_result, "-438782924007318");
  printf ("Test 437: i1 i2 * 13 - f1 f4 / *\n");
  printf ("Test 437: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_integer_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    printf ("Test 437: result = ");
    packed_string_integer_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 437: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 437: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 437: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void float_result_postfix_expression_test1 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "0", FALSE);
  correct_result = packed_string_float_initialize_to_zero (correct_result);
  printf ("Test 1: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 1: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 1: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  printf ("\n");
}




void float_result_postfix_expression_test2 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "12", FALSE);
  correct_result = packed_string_float_set_value (correct_result, "12");
  printf ("Test 2: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 2: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 2: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  printf ("\n");
}




void float_result_postfix_expression_test3 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  correct_result = packed_string_float_set_value (correct_result, "1");
  printf ("Test 3: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 3: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 3: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  printf ("\n");
}




void float_result_postfix_expression_test4 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", FALSE);
  correct_result = packed_string_float_initialize_to_zero (correct_result);
  printf ("Test 4: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 4: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 4: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  printf ("\n");
}




void float_result_postfix_expression_test5 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", FALSE);
  correct_result = packed_string_float_set_value (correct_result, "54321.12345");
  printf ("Test 5: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 5: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 5: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  printf ("\n");
}




void float_result_postfix_expression_test6 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  correct_result = packed_string_float_set_value (correct_result, "123");
  printf ("Test 6: i1\n");
  printf ("Test 6: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 6: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 6: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




void float_result_postfix_expression_test7 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result, *f1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  correct_result = packed_string_float_set_value (correct_result, "123.456");
  printf ("Test 7: f1\n");
  printf ("Test 7: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 7: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 7: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




void float_result_postfix_expression_test8 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  unsigned char *b1;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  { 
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  correct_result = packed_string_float_set_value (correct_result, "1");
  printf ("Test 8: b1\n");
  printf ("Test 8: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 8: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 8: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




void float_result_postfix_expression_test9 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  unsigned char is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "3", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = packed_string_float_set_value (correct_result, "6");
  printf ("Test 9: 12 2 3 * -\n");
  printf ("Test 9: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 9: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 9: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  printf ("\n");
}




void float_result_postfix_expression_test10 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *b1, *b2, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "200", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = packed_string_float_initialize_to_zero (correct_result);
  printf ("Test 10: i1 200 * f1 - b1 + b1 %%\n");
  printf ("Test 10: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 10: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 10: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void float_result_postfix_expression_test11 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *b1, *b2, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f2, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i4, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f4, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i2, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _plus);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_float_set_value (correct_result, "437258851.181145");
  printf ("Test 11: i1 f2 b1 i4 f4 f1 i2 * * * * + *\n");
  printf ("Test 11: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 11: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 11: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void float_result_postfix_expression_test12 (void)
{
  runtime_expression_node *expression;
  psflt *result, *correct_result;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *b1, *b2, is_correct;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i2, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "13", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f4, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = packed_string_float_set_value (correct_result, "-438782924007318");
  printf ("Test 12: i1 i2 * 13 - f1 f4 / *\n");
  printf ("Test 12: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_float_result_for_set_statement (expression);
  if (result != NULL)
  {
    is_correct = packed_string_float_equal (result, correct_result);
    printf ("Test 12: result = ");
    packed_string_float_display (result, 0);
    printf ("\n");
    if (is_correct == TRUE)
    {
      printf ("Test 12: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("Test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test1 (void)
{
  runtime_expression_node *expression;
  unsigned char *result, *correct_result;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "0", FALSE);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = FALSE;
  }
  printf ("Test 1: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 1: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 1: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test2 (void)
{
  runtime_expression_node *expression;
  unsigned char *result, *correct_result;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "12", FALSE);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 2: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 2: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 2: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test3 (void)
{
  runtime_expression_node *expression;
  unsigned char *result, *correct_result;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);

  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 3: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 3: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 3: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test4 (void)
{
  runtime_expression_node *expression;
  unsigned char *result, *correct_result;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", FALSE);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = FALSE;
  }
  printf ("Test 4: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 4: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 4: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test5 (void)
{
  runtime_expression_node *expression;
  unsigned char *result, *correct_result;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", FALSE);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 5: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 5: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 5: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test6 (void)
{
  runtime_expression_node *expression;
  psint *i1;
  unsigned char *result, *correct_result;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 6: i1\n");
  printf ("Test 6: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 6: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 6: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test7 (void)
{
  runtime_expression_node *expression;
  psflt *f1;
  unsigned char *result, *correct_result;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  f1             = NULL;
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 7: f1\n");
  printf ("Test 7: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 7: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 7: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test8 (void)
{
  runtime_expression_node *expression;
  unsigned char *result, *correct_result, *b1;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  { 
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 8: b1\n");
  printf ("Test 8: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 8: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 8: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test9 (void)
{
  runtime_expression_node *expression;
  unsigned char *result, *correct_result;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "3", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 9: 12 2 3 * -\n");
  printf ("Test 9: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 9: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 9: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test10 (void)
{
  runtime_expression_node *expression;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *result, *correct_result, *b1, *b2;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "200", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = FALSE;
  }
  printf ("Test 10: i1 200 * f1 - b1 + b1 %%\n");
  printf ("Test 10: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 10: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 10: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test11 (void)
{
  runtime_expression_node *expression;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *result, *correct_result, *b1, *b2;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f2, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i4, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f4, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i2, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _plus);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 11: i1 f2 b1 i4 f4 f1 i2 * * * * + *\n");
  printf ("Test 11: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 11: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 11: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void bool_result_postfix_expression_test12 (void)
{
  runtime_expression_node *expression;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char *result, *correct_result, *b1, *b2;

  expression     = NULL;
  correct_result = NULL;
  result         = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i2, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "13", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f4, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = (unsigned char *) malloc(sizeof(unsigned char));
  if (correct_result != NULL)
  {
    *correct_result = TRUE;
  }
  printf ("Test 12: i1 i2 * 13 - f1 f4 / *\n");
  printf ("Test 12: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result_for_set_statement (expression);
  if (result != NULL)
  {
    printf ("Test 12: result = ");
    boolean_display (result);
    printf ("\n");
    if (correct_result != NULL)
    {
      if (*result == *correct_result)
      {
        printf ("Test 12: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("Test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("Test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("Test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = boolean_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = boolean_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test1 (void)
{
  runtime_expression_node *expression;
  unsigned char result, correct_result;

  expression = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "0", FALSE);
  correct_result = FALSE;
  printf ("Test 1: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 1: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 1: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test2 (void)
{
  runtime_expression_node *expression;
  unsigned char result, correct_result;

  expression = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "12", FALSE);
  correct_result = TRUE;
  printf ("Test 2: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 2: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 2: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test3 (void)
{
  runtime_expression_node *expression;
  unsigned char result, correct_result;

  expression = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "TRUE", FALSE);
  correct_result = TRUE;
  printf ("Test 3: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 3: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 3: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test4 (void)
{
  runtime_expression_node *expression;
  unsigned char result, correct_result;

  expression = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_bool, "FALSE", FALSE);
  correct_result = FALSE;
  printf ("Test 4: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 4: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 4: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test5 (void)
{
  runtime_expression_node *expression;
  unsigned char result, correct_result;

  expression     = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_float, "54321.12345", FALSE);
  correct_result = TRUE;
  printf ("Test 5: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 5: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 5: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test6 (void)
{
  runtime_expression_node *expression;
  psint *i1;
  unsigned char result, correct_result;

  expression     = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "123");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  correct_result = TRUE;
  printf ("Test 6: i1\n");
  printf ("Test 6: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 6: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 6: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test7 (void)
{
  runtime_expression_node *expression;
  psflt *f1;
  unsigned char result, correct_result;

  expression = NULL;
  f1 = NULL;
  f1 = packed_string_float_set_value (f1, "123.456");
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  correct_result = TRUE;
  printf ("Test 7: f1\n");
  printf ("Test 7: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 7: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 7: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test8 (void)
{
  runtime_expression_node *expression;
  unsigned char result, correct_result, *b1;

  expression = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  { 
    *b1 = TRUE;
  }
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  correct_result = TRUE;
  printf ("Test 8: b1\n");
  printf ("Test 8: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 8: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 8: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test9 (void)
{
  runtime_expression_node *expression;
  unsigned char result, correct_result;

  expression = NULL;
  expression = add_operand_element_runtime_expression (expression, _constant_int, "12", FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "2", FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "3", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _minus);
  correct_result = TRUE;
  printf ("Test 9: 12 2 3 * -\n");
  printf ("Test 9: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 9: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 9: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test10 (void)
{
  runtime_expression_node *expression;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char result, correct_result, *b1, *b2;

  expression = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "200", FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _plus);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operator_element_runtime_expression (expression, _modulo);
  correct_result = FALSE;
  printf ("Test 10: i1 200 * f1 - b1 + b1 %%\n");
  printf ("Test 10: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 10: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 10: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test11 (void)
{
  runtime_expression_node *expression;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char result, correct_result, *b1, *b2;

  expression = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f2, FALSE);
  expression = add_operand_element_runtime_expression (expression, _bool, b1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i4, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f4, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i2, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operator_element_runtime_expression (expression, _plus);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = TRUE;
  printf ("Test 11: i1 f2 b1 i4 f4 f1 i2 * * * * + *\n");
  printf ("Test 11: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 11: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 11: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void bool_result_for_conditional_statements_postfix_expression_test12 (void)
{
  runtime_expression_node *expression;
  psint *i1, *i2, *i3, *i4, *i5;
  psflt *f1, *f2, *f3, *f4, *f5;
  unsigned char result, correct_result, *b1, *b2;

  expression = NULL;
  i1 = NULL;
  i2 = NULL;
  i3 = NULL;
  i4 = NULL;
  i5 = NULL;
  f1 = NULL;
  f2 = NULL;
  f3 = NULL;
  f4 = NULL;
  f5 = NULL;
  b1 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b1 = TRUE;
  }
  b2 = (unsigned char *) malloc(sizeof(unsigned char));
  if (b1 != NULL)
  {
    *b2 = FALSE;
  }
  i1 = packed_string_integer_set_value (i1, "12345");
  i2 = packed_string_integer_set_value (i2, "-54321");
  i3 = packed_string_integer_set_value (i3, "0");
  i4 = packed_string_integer_set_value (i4, "-1");
  i5 = packed_string_integer_set_value (i5, "999999999");
  f1 = packed_string_float_set_value (f1, "654.321");
  f2 = packed_string_float_set_value (f2, "-123.456");
  f3 = packed_string_float_set_value (f3, "9999.999");
  f4 = packed_string_float_set_value (f4, "0.001");
  f5 = packed_string_float_set_value (f5, "987654321987654321.123456789");
  expression = add_operand_element_runtime_expression (expression, _int, i1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _int, i2, FALSE);
  expression = add_operator_element_runtime_expression (expression, _times);
  expression = add_operand_element_runtime_expression (expression, _constant_int, "13", FALSE);
  expression = add_operator_element_runtime_expression (expression, _minus);
  expression = add_operand_element_runtime_expression (expression, _float, f1, FALSE);
  expression = add_operand_element_runtime_expression (expression, _float, f4, FALSE);
  expression = add_operator_element_runtime_expression (expression, _divide);
  expression = add_operator_element_runtime_expression (expression, _times);
  correct_result = TRUE;
  printf ("Test 12: i1 i2 * 13 - f1 f4 / *\n");
  printf ("Test 12: ");
  display_postfix_expression_compact (expression);
  printf ("\n");
  result = evaluate_runtime_expression_return_boolean_result (expression);
  printf ("Test 12: result = ");
  boolean_display (&result);
  printf ("\n");
  if (result == correct_result)
  {
    printf ("Test 12: \033[1m\033[32mPass\033[0m\033[0m\n");
  }
  else
  {
    printf ("Test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  if (f3 != NULL)
  {
    f3 = packed_string_float_release_memory (f3);
  }
  if (f4 != NULL)
  {
    f4 = packed_string_float_release_memory (f4);
  }
  if (f5 != NULL)
  {
    f5 = packed_string_float_release_memory (f5);
  }
  if (b1 != NULL)
  {
    b1 = boolean_release_memory (b1);
  }
  if (b2 != NULL)
  {
    b2 = boolean_release_memory (b2);
  }
  printf ("\n");
}




void libchaga_test1 (void)
{
  psint *result, *correct_result;
  psint *i1;
  unsigned char is_correct;

  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i1 = packed_string_integer_set_value (i1, "1000");
  correct_result = packed_string_integer_set_value (correct_result, "402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
  result = packed_string_integer_factorial (i1);
  printf ("libchaga test 1: COMPUTE 1000 factorial: RESULT = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 1: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 1: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  printf ("\n");
}



void libchaga_test2 (void)
{
  psint *result, *correct_result;
  psint *i1, *i2;
  unsigned char is_correct;

  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i2             = NULL;
  i1 = packed_string_integer_set_value (i1, "+1234567890123456789012345678901234567890");
  i2 = packed_string_integer_set_value (i2, "-987654321987654321987654321");
  correct_result = packed_string_integer_set_value (correct_result, "-1219326312467611633592440164485596706448437738013609205901126352690");
  result = packed_string_integer_multiply (result, i1, i2);
  printf ("LibChaga test 2: COMPUTE 1234567890123456789012345678901234567890 * -987654321987654321987654321: RESULT = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 2: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 2: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  printf ("\n");
}




void libchaga_test3 (void)
{
  psint *result, *correct_result;
  psint *i1, *i2, *i3, *i4, *i5, *i6, *i7, *i8;
  unsigned char is_correct;

  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i2             = NULL;
  i3             = NULL;
  i4             = NULL;
  i5             = NULL;
  i6             = NULL;
  i7             = NULL;
  i8             = NULL;
  i1 = packed_string_integer_set_value (i1, "99999999999999999");
  i2 = packed_string_integer_set_value (i2, "88888888888888888");
  i3 = packed_string_integer_set_value (i3, "77777777777777777");
  i4 = packed_string_integer_set_value (i4, "66666666666666666");
  i5 = packed_string_integer_set_value (i5, "55555555555555555");
  i6 = packed_string_integer_add (i6, i1, i2);
  i7 = packed_string_integer_add (i7, i3, i4);
  i8 = packed_string_integer_add (i8, i6, i7);
  result = packed_string_integer_add (result, i8, i5);
  correct_result = packed_string_integer_set_value (correct_result, "388888888888888885");
  printf ("libchaga test 3: COMPUTE 99999999999999999 + 88888888888888888 + 77777777777777777 + 66666666666666666 + 55555555555555555: RESULT = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 3: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 3: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  if (i3 != NULL)
  {
    i3 = packed_string_integer_release_memory (i3);
  }
  if (i4 != NULL)
  {
    i4 = packed_string_integer_release_memory (i4);
  }
  if (i5 != NULL)
  {
    i5 = packed_string_integer_release_memory (i5);
  }
  if (i6 != NULL)
  {
    i6 = packed_string_integer_release_memory (i6);
  }
  if (i7 != NULL)
  {
    i7 = packed_string_integer_release_memory (i7);
  }
  if (i8 != NULL)
  {
    i8 = packed_string_integer_release_memory (i8);
  }
  printf ("\n");
}



void libchaga_test4 (void)
{
  psint *result, *correct_result;
  psint *i1, *i2;
  unsigned char is_correct;

  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i2             = NULL;
  i1 = packed_string_integer_set_value (i1, "11111010101111111000000111100000000000000000000111111000000000000000100000000000000000");
  i2 = packed_string_integer_set_value (i2, "9999999999999999999999999999999999999999999999999999999999999999999999999999");
  result = packed_string_integer_subtract (result, i1, i2);
  correct_result = packed_string_integer_set_value (correct_result, "11111010091111111000000111100000000000000000000111111000000000000000100000000000000001");
  printf ("libchaga test 4: COMPUTE 11111010101111111000000111100000000000000000000111111000000000000000100000000000000000 - 9999999999999999999999999999999999999999999999999999999999999999999999999999: RESULT = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 4: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 4: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  printf ("\n");
}




void libchaga_test5 (void)
{
  psint *result, *correct_result;
  psint *i1, *i2;
  unsigned char is_correct;

  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i2             = NULL;
  i1 = packed_string_integer_set_value (i1, "123456789012345678901234567890123456789012345678901234567890");
  i2 = packed_string_integer_set_value (i2, "987654321987654321098765432109876543210");
  result = packed_string_integer_divide (result, i1, i2);
  correct_result = packed_string_integer_set_value (correct_result, "124999998748437501140");
  printf ("libchaga test 5: COMPUTE 123456789012345678901234567890123456789012345678901234567890 / 987654321987654321098765432109876543210: RESULT = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 5: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 5: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  printf ("\n");
}





void libchaga_test6 (void)
{
  psint *result, *correct_result;
  psint *i1, *i2;
  unsigned char is_correct;

  correct_result = NULL;
  result         = NULL;
  i1             = NULL;
  i2             = NULL;
  i1 = packed_string_integer_set_value (i1, "123456789012345678901234567890123456789012345678901234567890");
  i2 = packed_string_integer_set_value (i2, "987654321987654321098765432109876543210");
  result = packed_string_integer_modulo (result, i1, i2);
  correct_result = packed_string_integer_set_value (correct_result, "636573060636573960187114184907600308490");
  printf ("libchaga test 6: COMPUTE 123456789012345678901234567890123456789012345678901234567890 %% 987654321987654321098765432109876543210: RESULT = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_integer_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 6: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 6: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_integer_release_memory (correct_result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  printf ("\n");
}




void libchaga_test7 (void)
{
  psflt *result, *expected_result, *f1;
  unsigned char is_correct;

  expected_result = NULL;
  result = NULL;
  f1     = NULL;
  f1 = packed_string_float_set_value (f1, "2000");
  result = packed_string_float_nth_root_with_bisection_method (result, f1, 3);
  expected_result = packed_string_float_set_value (expected_result, "12.599210498948731647672106074266256726083166558025601216262712167548443176201544702053070068359375");
  printf ("libchaga test 7: COMPUTE cube root of 2000 using bisection method: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (expected_result != NULL))
  {
    is_correct = packed_string_float_equal (result, expected_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 7: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 7: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (expected_result != NULL)
  {
    expected_result = packed_string_float_release_memory (expected_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




void libchaga_test8 (void)
{
  psflt *result, *expected_result, *f1;
  unsigned char is_correct;

  expected_result = NULL;
  result = NULL;
  f1     = NULL;
  f1 = packed_string_float_set_value (f1, "2000");
  result = packed_string_float_nth_root_with_newton_raphson_method (result, f1, 3);
  expected_result = packed_string_float_set_value (expected_result, "12.5992104989487316476721060727822835057025146470150798008197511215529967651395948372939656243625509415431025603561567378030674842081425002497232185199478478976040814663978803863250495587972688930098923486025801026774573743473402766005913215900864754973642795722365638114620594250309393132961130402432663937753404646750410223468235823310087001618990696299850340020809594770888850218443459519159412368270613230262416960781841888596116156753289314731564851792548141064327388016869491589839602513231588745875182699559160141179449511273516584744823298430080463671038053413816898294272490879146198382470776305862410626656625132327954827007096670130616309129583184528061924077037639983789123574086885174844247209913940596708993388569587205070366142336583512450848530298357431737939611747239292359581191566371871899046354260434750371752473252534123997698945110290964161826978764523278709017598125824960505936223248871547092304951392683866609353789500986339528707574192416710211613594286700594073018227934134487");
  printf ("libchaga test 8: COMPUTE cube root of 2000 using Newton-Raphson method seeded with bisection method: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (expected_result != NULL))
  {
    is_correct = packed_string_float_equal (result, expected_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 8: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 8: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (expected_result != NULL)
  {
    expected_result = packed_string_float_release_memory (expected_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




void libchaga_test9 (void)
{
  psflt *result, *expected_result, *f1;
  unsigned char is_correct;

  expected_result = NULL;
  result = NULL;
  f1     = NULL;
  f1 = packed_string_float_set_value (f1, "12.5992104989487316476721060727822835057025146470150798008197511215529967651395948372939656243625509415431025603561567378030674842081425002497232185199478478976040814663978803863250495587972688930098923486025801026774573743473402766005913215900864754973642795722365638114620594250309393132961130402432663937753404646750410223468235823310087001618990696299850340020809594770888850218443459519159412368270613230262416960781841888596116156753289314731564851792548141064327388016869491589839602513231588745875182699559160141179449511273516584744823298430080463671038053413816898294272490879146198382470776305862410626656625132327954827007096670130616309129583184528061924077037639983789123574086885174844247209913940596708993388569587205070366142336583512450848530298357431737939611747239292359581191566371871899046354260434750371752473252534123997698945110290964161826978764523278709017598125824960505936223248871547092304951392683866609353789500986339528707574192416710211613594286700594073018227934134487");
  result = packed_string_float_power (result, f1, 3);
  expected_result = packed_string_float_set_value (expected_result, "2000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040578293656215261002269756565357781326317399279676944145935521997760143244159949292683102523124340839763870611937763164123147060317332327908828047792682029886895069534499688567833297847511710199685642087654410207991015857094890843178546152346342658981371263637229548618014593608911484990496248211650232043019270820549476980581517970658966383466475507822460450636466643571839204913170437704095503955887790122489794603407784167167274157955610785608942561780705086130189002385958265459764201035233361459138014940612970121310444753453933293433246977670558684087758859986990650322308623874988331915750358752237718591558425871665107710769934658749923719892188630883047674514170880709742421591570091045798512394541652708135579192727613191128238164156540711188211326678521408042393003804482752691582811126953139434301380682774823148719528894312756308065030296902522359615909052739841193182886766412984442852690054727438529749469542516004062955867236770875787531938875724835196281631869497086675958376116936199424366410344070203628429694864357523621557668504164932380504672605537621685435939941930800651898115387355848392713994164660630943895256792144271631474591844814665682973707027508207943817951966469056890186065178596863017199526994738274892882212844216852601518318586089732144392014625541160547011121033031095832654064346038503473195352082727277128936881761547537305370936226595867707238745540267311905617783470382341508231281436517935846078173311637054185437141089919194111779512381223940296341253033768563655470434965132269738369087690776684765468387665809043645121367026704560636610754611474567787230245741788153394820741666068328701200201624401508003467530346322642480264127083626132626157331730412552370590823965171238089284898510074438122037261585273130565345967926044243529407927903242973353853109082884281994331801518120143730527415596668760690253039690536686192219803427830900650000557571175208095265737314277777276609984762931585708604927145907150247001465160035315327933491058413646914635835712070814628175740707356328481163376382674718524513014442471863030125710374512801119536936374909941167826871404987194859050351179905258863600342442287906872930645397373538483804743684948943506667076621173901596352178777862129689040276780474681249234313271974867923373351642120047758174746888814389881689338800198652899944336915411865768996086675957869277720942048805244270952179394601308413435237217762985504370445808800344970280097030921487932919723536051312527580231453291900512610258771568820706555765841463294071521555087186242955753163692511605600589523004308502086730985635814196117867873930250109145985186131220058345679414898648362053391773138071203874383183554666790501389052115169613749028766629435534024494428442578141145740036256242864669894577656474002561458391542212759816788413051153953147580804633283882771740522304094868901022589107316069616287488696141662664901711439303");
  printf ("libchaga test 9: COMPUTE test result eight raised to the third power: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (expected_result != NULL))
  {
    is_correct = packed_string_float_equal (result, expected_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 9: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 9: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (expected_result != NULL)
  {
    expected_result = packed_string_float_release_memory (expected_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  printf ("\n");
}




void libchaga_test10 (void)
{
  psflt *result, *correct_result, *f1, *f2;
  unsigned char is_correct;

  correct_result = NULL;
  result = NULL;
  f1     = NULL;
  f2     = NULL;
  f1 = packed_string_float_set_value (f1, "1234567890.0987654321");
  f2 = packed_string_float_set_value (f2, "123123123123.456456456");
  result = packed_string_float_add (result, f1, f2);
  correct_result = packed_string_float_set_value (correct_result, "124357691013.5552218881");
  printf ("libchaga test 10: COMPUTE the sum of 1234567890.0987654321 + 123123123123.456456456: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_float_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 10: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 10: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}




void libchaga_test11 (void)
{
  psflt *result, *correct_result, *f1, *f2;
  unsigned char is_correct;

  correct_result = NULL;
  result = NULL;
  f1     = NULL;
  f2     = NULL;
  f1 = packed_string_float_set_value (f1, "1000000010000000.000000000100000000001");
  f2 = packed_string_float_set_value (f2, "090909090909090909090909090909.090909090909090090909090909090909090909090909090909090909090909");
  result = packed_string_float_subtract (result, f1, f2);
  correct_result = packed_string_float_set_value (correct_result, "-90909090909089909090899090909.090909090809090090908090909090909090909090909090909090909090909");
  printf ("libchaga test 11: COMPUTE the difference of 1000000010000000.000000000100000000001 - 090909090909090909090909090909.090909090909090090909090909090909090909090909090909090909090909: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_float_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 11: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 11: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}




void libchaga_test12 (void)
{
  psflt *result, *correct_result, *f1, *f2;
  unsigned char is_correct;

  correct_result = NULL;
  result = NULL;
  f1     = NULL;
  f2     = NULL;
  f1 = packed_string_float_set_value (f1, "0.00000000000000000123000123000012300001230009");
  f2 = packed_string_float_set_value (f2, "87654321.09");
  result = packed_string_float_multiply (result, f1, f2);
  correct_result = packed_string_float_set_value (correct_result, "0.0000000001078149227555257221825722260382958981");
  printf ("libchaga test 12: COMPUTE the product of 0.00000000000000000123000123000012300001230009 * 87654321.09: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_float_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 12: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 12: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}




void libchaga_test13 (void)
{
  psflt *result, *correct_result, *f1, *f2;
  unsigned char is_correct;
  unsigned long long int num_digits_of_precision_right_of_decimal;

  correct_result = NULL;
  result = NULL;
  f1     = NULL;
  f2     = NULL;
  num_digits_of_precision_right_of_decimal = 10;
  f1 = packed_string_float_set_value (f1, "3");
  f2 = packed_string_float_set_value (f2, "8");
  result = packed_string_float_divide (result, f1, f2, num_digits_of_precision_right_of_decimal);
  correct_result = packed_string_float_set_value (correct_result, "0.375");
  printf ("libchaga test 13: COMPUTE floating-point division of 3 / 8: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (correct_result != NULL))
  {
    is_correct = packed_string_float_equal (result, correct_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 13: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 13: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 13: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (correct_result != NULL)
  {
    correct_result = packed_string_float_release_memory (correct_result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}




void libchaga_test14 (void)
{
  psflt *result, *f1, *f2;
  unsigned long long int num_digits_of_precision_right_of_decimal;

  result = NULL;
  f1     = NULL;
  f2     = NULL;
  num_digits_of_precision_right_of_decimal = 10;
  f1 = packed_string_float_set_value (f1, "1");
  f2 = packed_string_float_set_value (f2, "0");
  result = packed_string_float_divide (result, f1, f2, num_digits_of_precision_right_of_decimal);
  printf ("libchaga test 14: COMPUTE floating-point division of 1 / 0: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if (result != NULL)
  {
    if (result->sign == undefined)
    {
      if ((result->status_flag & 0x4000) == DIVIDE_BY_ZERO)
      {
        printf ("LibChaga test 14: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("LibChaga test 14: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("LibChaga test 14: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 14: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}





void libchaga_test15 (void)
{
  psint *result, *i1, *i2;

  result = NULL;
  i1     = NULL;
  i2     = NULL;
  i1 = packed_string_integer_set_value (i1, "1");
  i2 = packed_string_integer_set_value (i2, "0");
  result = packed_string_integer_divide (result, i1, i2);
  printf ("libchaga test 15: COMPUTE integer division of 1 / 0: RESULT = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if (result != NULL)
  {
    if (result->sign == undefined)
    {
      if ((result->status_flag & 0x4000) == DIVIDE_BY_ZERO)
      {
        printf ("LibChaga test 15: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("LibChaga test 15: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("LibChaga test 15: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 15: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  printf ("\n");
}




void libchaga_test16 (void)
{
  psflt *result, *expected_result, *f1, *f2;
  unsigned char is_correct;
  unsigned long long int num_digits_of_precision_right_of_decimal;

  expected_result = NULL;
  result = NULL;
  f1 = NULL;
  f2 = NULL;
  num_digits_of_precision_right_of_decimal = 100;
  f1 = packed_string_float_set_value (f1, "1");
  f2 = packed_string_float_set_value (f2, "7");
  result = packed_string_float_divide (result, f1, f2, num_digits_of_precision_right_of_decimal);
  expected_result = packed_string_float_set_value (expected_result, "0.1428571428571428571428571428571428571428571428571428571428571428571428571428571428571428571428571428");
  printf ("Libchaga test 16: Testing floating-point division with a repeating, non-terminating remainder with 100 digits of precision right of the decimal.\n");
  printf ("libchaga test 16: COMPUTE floating-point division of 1 / 7: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (expected_result != NULL))
  {
    is_correct = packed_string_float_equal (result, expected_result);
    if (is_correct == TRUE)
    {
      if ((result->status_flag & 0x2000) == REPEATING_NONTERMINATING)
      {
        printf ("LibChaga test 16: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("LibChaga test 16: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("LibChaga test 16: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 16: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}




void libchaga_test17 (void)
{
  psflt *result, *expected_result, *f1, *f2;
  unsigned char is_correct;
  unsigned long long int num_digits_of_precision_right_of_decimal;

  expected_result = NULL;
  result = NULL;
  f1 = NULL;
  f2 = NULL;
  num_digits_of_precision_right_of_decimal = 71;
  f1 = packed_string_float_set_value (f1, "1");
  f2 = packed_string_float_set_value (f2, "103");
  result = packed_string_float_divide (result, f1, f2, num_digits_of_precision_right_of_decimal);
  expected_result = packed_string_float_set_value (expected_result, "0.00970873786407766990291262135922330097087378640776699029126213592233009");
  printf ("Libchaga test 17: Testing floating-point division with a repeating, non-terminating remainder with 71 digits of precision right of the decimal.\n");
  printf ("libchaga test 17: COMPUTE floating-point division of 1 / 103: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (expected_result != NULL))
  {
    is_correct = packed_string_float_equal (result, expected_result);
    if (is_correct == TRUE)
    {
      if ((result->status_flag & 0x2000) == REPEATING_NONTERMINATING)
      {
        printf ("LibChaga test 17: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("LibChaga test 17: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("LibChaga test 17: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 17: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}




void libchaga_test18 (void)
{
  psflt *result, *expected_result, *f1, *f2;
  unsigned char is_correct;
  unsigned long long int num_digits_of_precision_right_of_decimal;

  expected_result = NULL;
  result = NULL;
  f1 = NULL;
  f2 = NULL;
  num_digits_of_precision_right_of_decimal = 8;
  f1 = packed_string_float_set_value (f1, "1");
  f2 = packed_string_float_set_value (f2, "99");
  result = packed_string_float_divide (result, f1, f2, num_digits_of_precision_right_of_decimal);
  expected_result = packed_string_float_set_value (expected_result, "0.01010101");
  printf ("Libchaga test 18: Testing floating-point division with a repeating, non-terminating remainder with 8 digits of precision right of the decimal.\n");
  printf ("libchaga test 18: COMPUTE floating-point division of 1 / 99: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (expected_result != NULL))
  {
    is_correct = packed_string_float_equal (result, expected_result);
    if (is_correct == TRUE)
    {
      if ((result->status_flag & 0x2000) == REPEATING_NONTERMINATING)
      {
        printf ("LibChaga test 18: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("LibChaga test 18: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("LibChaga test 18: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 18: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}




void libchaga_test19 (void)
{
  psflt *result, *expected_result, *f1, *f2;
  unsigned char is_correct;
  unsigned long long int num_digits_of_precision_right_of_decimal;

  expected_result = NULL;
  result = NULL;
  f1 = NULL;
  f2 = NULL;
  num_digits_of_precision_right_of_decimal = 1;
  f1 = packed_string_float_set_value (f1, "1");
  f2 = packed_string_float_set_value (f2, "3");
  result = packed_string_float_divide (result, f1, f2, num_digits_of_precision_right_of_decimal);
  expected_result = packed_string_float_set_value (expected_result, "0.3");
  printf ("Libchaga test 19: Testing floating-point division with a repeating, non-terminating remainder with 1 digit of precision right of the decimal.\n");
  printf ("libchaga test 19: COMPUTE floating-point division of 1 / 3: RESULT = ");
  packed_string_float_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (expected_result != NULL))
  {
    is_correct = packed_string_float_equal (result, expected_result);
    if (is_correct == TRUE)
    {
      if ((result->status_flag & 0x2000) == REPEATING_NONTERMINATING)
      {
        printf ("LibChaga test 19: \033[1m\033[32mPass\033[0m\033[0m\n");
      }
      else
      {
        printf ("LibChaga test 19: \033[1m\033[31mFAIL\033[0m\033[0m\n");
        exit (EXIT_FAILURE);
      }
    }
    else
    {
      printf ("LibChaga test 19: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 19: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_float_release_memory (result);
  }
  if (f1 != NULL)
  {
    f1 = packed_string_float_release_memory (f1);
  }
  if (f2 != NULL)
  {
    f2 = packed_string_float_release_memory (f2);
  }
  printf ("\n");
}



void libchaga_test20 (void)
{
  psint *result, *expected_result, *i1, *i2;
  unsigned char is_correct;
  unsigned long long int num_digits_of_precision_right_of_decimal;
  unsigned long long int current_fibonacci_term, number_of_fibonacci_terms;
  int state;

  expected_result = NULL;
  result = NULL;
  i1 = NULL;
  i2 = NULL;
  expected_result = packed_string_integer_set_value (expected_result, "43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875");
  printf ("libchaga test 20: COMPUTE 1000 terms of the Fibonacci series\n");
  state = 0;
  current_fibonacci_term = 0;
  number_of_fibonacci_terms = 1000;
  while (current_fibonacci_term <= number_of_fibonacci_terms)
  {
    printf ("F(%llu) = ", current_fibonacci_term);
    switch (state)
    {
      case 0:
        i1 = packed_string_integer_set_value (i1, "0");
        packed_string_integer_display (i1, 0);
        state = 1;
      break;
      case 1:
        i2 = packed_string_integer_set_value (i2, "1");
        packed_string_integer_display (i2, 0);
        state = 2;  
      break;
      case 2:
        result = packed_string_integer_add (result, i1, i2);
        packed_string_integer_display (result, 0);
        i1 = packed_string_integer_release_memory (i1);
        i1 = packed_string_integer_copy_number (i1, result);
        if (current_fibonacci_term < number_of_fibonacci_terms)
        {
          result = packed_string_integer_release_memory (result);
        }
        state = 3;  
      break;
      case 3:
        result = packed_string_integer_add (result, i1, i2);
        packed_string_integer_display (result, 0);
        i2 = packed_string_integer_release_memory (i2);
        i2 = packed_string_integer_copy_number (i2, result);
        if (current_fibonacci_term < number_of_fibonacci_terms)
        {
          result = packed_string_integer_release_memory (result);
        }
        state = 2;  
      break;
      default:
        printf ("\n\n");
        printf ("Oops! Should not be here. state = %d. Exiting now.\n", state);
        exit (EXIT_FAILURE);
      break;
    }     
    printf ("\n");
    current_fibonacci_term++;
  }
  printf ("libchaga test 20: The 1000th Fibonacci term = ");
  packed_string_integer_display (result, 0);
  printf ("\n");
  if ((result != NULL) && (expected_result != NULL))
  {
    is_correct = packed_string_integer_equal (result, expected_result);
    if (is_correct == TRUE)
    {
      printf ("LibChaga test 20: \033[1m\033[32mPass\033[0m\033[0m\n");
    }
    else
    {
      printf ("LibChaga test 20: \033[1m\033[31mFAIL\033[0m\033[0m\n");
      exit (EXIT_FAILURE);
    }
  }
  else
  {
    printf ("LibChaga test 20: \033[1m\033[31mFAIL\033[0m\033[0m\n");
    exit (EXIT_FAILURE);
  }
  if (result != NULL)
  {
    result = packed_string_integer_release_memory (result);
  }
  if (i1 != NULL)
  {
    i1 = packed_string_integer_release_memory (i1);
  }
  if (i2 != NULL)
  {
    i2 = packed_string_integer_release_memory (i2);
  }
  printf ("\n");
}


