text:
<?xml version="1.0" encoding="UTF-8"?>
<SPC5-Config version="1.0.0">
  <application name="ChibiOS/NIL Test Suite" version="1.0.0" standalone="true" locked="false">
    <description>Test Specification for ChibiOS/NIL.</description>
    <component id="org.chibios.spc5.components.portable.generic_startup">
      <component id="org.chibios.spc5.components.portable.chibios_unitary_tests_engine" />
    </component>
    <instances>
      <instance locked="false" id="org.chibios.spc5.components.portable.generic_startup" />
      <instance locked="false" id="org.chibios.spc5.components.portable.chibios_unitary_tests_engine">
        <description>
          <copyright>
            <value><![CDATA[]]></value>
          </copyright>
          <introduction>
            <value>Test suite for ChibiOS/NIL. The purpose of this suite is to perform unit tests on the NIL modules and to converge to 100% code coverage through successive improvements.</value>
          </introduction>
        </description>
        <global_data_and_code>
          <global_definitions>
            <value><![CDATA[#define TEST_SUITE_NAME                     "ChibiOS/NIL Test Suite"

#define TEST_REPORT_HOOK_HEADER test_print_port_info();

extern semaphore_t gsem1, gsem2;
extern thread_reference_t gtr1;
extern THD_WORKING_AREA(wa_test_support, 128);

void test_print_port_info(void);
THD_FUNCTION(test_support, arg);]]></value>
          </global_definitions>
          <global_code>
            <value><![CDATA[void test_print_port_info(void) {

#ifdef PORT_COMPILER_NAME
  test_print("*** Compiler:     ");
  test_println(PORT_COMPILER_NAME);
#endif
  test_print("*** Architecture: ");
  test_println(PORT_ARCHITECTURE_NAME);
#ifdef PORT_CORE_VARIANT_NAME
  test_print("*** Core Variant: ");
  test_println(PORT_CORE_VARIANT_NAME);
#endif
#ifdef PORT_INFO
  test_print("*** Port Info:    ");
  test_println(PORT_INFO);
#endif
}

semaphore_t gsem1, gsem2;
thread_reference_t gtr1;

/*
 * Support thread.
 */
THD_WORKING_AREA(wa_test_support, 128);
THD_FUNCTION(test_support, arg) {
#if CH_CFG_USE_EVENTS == TRUE
  thread_t *tp = (thread_t *)arg;
#else
  (void)arg;
#endif

  /* Initializing global resources.*/
  chSemObjectInit(&gsem1, 0);
  chSemObjectInit(&gsem2, 0);

  while (true) {
    chSysLock();
    if (chSemGetCounterI(&gsem1) < 0)
      chSemSignalI(&gsem1);
    chSemResetI(&gsem2, 0);
    chThdResumeI(&gtr1, MSG_OK);
#if CH_CFG_USE_EVENTS == TRUE
    chEvtSignalI(tp, 0x55);
#endif
    chSchRescheduleS();
    chSysUnlock();

    chThdSleepMilliseconds(250);
  }
}]]></value>
          </global_code>
        </global_data_and_code>
        <sequences>
          <sequence>
            <type index="0">
              <value>Internal Tests</value>
            </type>
            <brief>
              <value>Information.</value>
            </brief>
            <description>
              <value>This sequence reports configuration and version information about the NIL kernel.</value>
            </description>
            <condition>
              <value />
            </condition>
            <shared_code>
              <value><![CDATA[#include "ch.h"]]></value>
            </shared_code>
            <cases>
              <case>
                <brief>
                  <value>Kernel Info.</value>
                </brief>
                <description>
                  <value>The version numbers are reported.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value />
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value />
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Prints the version string.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_println("--- Product:                   ChibiOS/NIL");
test_print("--- Stable Flag:               ");
test_printn(CH_KERNEL_STABLE);
test_println("");
test_print("--- Version String:            ");
test_println(CH_KERNEL_VERSION);
test_print("--- Major Number:              ");
test_printn(CH_KERNEL_MAJOR);
test_println("");
test_print("--- Minor Number:              ");
test_printn(CH_KERNEL_MINOR);
test_println("");
test_print("--- Patch Number:              ");
test_printn(CH_KERNEL_PATCH);
test_println("");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Kernel Settings.</value>
                </brief>
                <description>
                  <value>The static kernel settings are reported.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value />
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value />
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Prints the configuration options settings.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_print("--- CH_CFG_NUM_THREADS:        ");
test_printn(CH_CFG_NUM_THREADS);
test_println("");
test_print("--- CH_CFG_ST_RESOLUTION:      ");
test_printn(CH_CFG_ST_RESOLUTION);
test_println("");
test_print("--- CH_CFG_ST_FREQUENCY:       ");
test_printn(CH_CFG_ST_FREQUENCY);
test_println("");
test_print("--- CH_CFG_ST_TIMEDELTA:       ");
test_printn(CH_CFG_ST_TIMEDELTA);
test_println("");
test_print("--- CH_CFG_USE_SEMAPHORES:     ");
test_printn(CH_CFG_USE_SEMAPHORES);
test_println("");
test_print("--- CH_CFG_USE_MUTEXES:        ");
test_printn(CH_CFG_USE_MUTEXES);
test_println("");
test_print("--- CH_CFG_USE_EVENTS:         ");
test_printn(CH_CFG_USE_EVENTS);
test_println("");
test_print("--- CH_CFG_USE_MAILBOXES:      ");
test_printn(CH_CFG_USE_MAILBOXES);
test_println("");
test_print("--- CH_CFG_USE_MEMCORE:        ");
test_printn(CH_CFG_USE_MEMCORE);
test_println("");
test_print("--- CH_CFG_USE_HEAP:           ");
test_printn(CH_CFG_USE_HEAP);
test_println("");
test_print("--- CH_CFG_USE_MEMPOOLS:       ");
test_printn(CH_CFG_USE_MEMPOOLS);
test_println("");
test_print("--- CH_DBG_STATISTICS:         ");
test_printn(CH_DBG_STATISTICS);
test_println("");
test_print("--- CH_DBG_SYSTEM_STATE_CHECK: ");
test_printn(CH_DBG_SYSTEM_STATE_CHECK);
test_println("");
test_print("--- CH_DBG_ENABLE_CHECKS:      ");
test_printn(CH_DBG_ENABLE_CHECKS);
test_println("");
test_print("--- CH_DBG_ENABLE_ASSERTS:     ");
test_printn(CH_DBG_ENABLE_ASSERTS);
test_println("");
test_print("--- CH_DBG_ENABLE_STACK_CHECK: ");
test_printn(CH_DBG_ENABLE_STACK_CHECK);
test_println("");]]></value>

                  </step>
                </steps>
              </case>
            </cases>
          </sequence>
          <sequence>
            <type index="0">
              <value>Internal Tests</value>
            </type>
            <brief>
              <value>Threads Functionality.</value>
            </brief>
            <description>
              <value>This sequence tests the ChibiOS/NIL functionalities related to threading.</value>
            </description>
            <condition>
              <value />
            </condition>
            <shared_code>
              <value><![CDATA[#include "ch.h"]]></value>
            </shared_code>
            <cases>
              <case>
                <brief>
                  <value>System Tick Counter functionality.</value>
                </brief>
                <description>
                  <value>The functionality of the API @p chVTGetSystemTimeX() is tested.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value />
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value />
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>A System Tick Counter increment is expected, the test simply hangs if it does not happen.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[systime_t time = chVTGetSystemTimeX();
while (time == chVTGetSystemTimeX()) {
}]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Thread Sleep functionality.</value>
                </brief>
                <description>
                  <value>The functionality of @p chThdSleep() and derivatives is tested.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value />
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[systime_t time;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>The current system time is read then a sleep is performed for 100 system ticks and on exit the system time is verified again.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
chThdSleep(100);
test_assert_time_window(time + 100,
                        time + 100 + 1,
                        "out of time window");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The current system time is read then a sleep is performed for 100000 microseconds and on exit the system time is verified again.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
chThdSleepMicroseconds(100000);
test_assert_time_window(time + US2ST(100000),
                        time + US2ST(100000) + 1,
                        "out of time window");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The current system time is read then a sleep is performed for 100 milliseconds and on exit the system time is verified again.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
chThdSleepMilliseconds(100);
test_assert_time_window(time + MS2ST(100),
                        time + MS2ST(100) + 1,
                        "out of time window");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The current system time is read then a sleep is performed for 1 second and on exit the system time is verified again.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
chThdSleepSeconds(1);
test_assert_time_window(time + S2ST(1),
                        time + S2ST(1) + 1,
                        "out of time window");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Function chThdSleepUntil() is tested with a timeline of "now" + 100 ticks.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
chThdSleepUntil(time + 100);
test_assert_time_window(time + 100,
                        time + 100 + 1,
                        "out of time window");]]></value>

                  </step>
                </steps>
              </case>
            </cases>
          </sequence>
          <sequence>
            <type index="0">
              <value>Internal Tests</value>
            </type>
            <brief>
              <value>Semaphores.</value>
            </brief>
            <description>
              <value>This sequence tests the ChibiOS/NIL functionalities related to counter semaphores.</value>
            </description>
            <condition>
              <value>CH_CFG_USE_SEMAPHORES</value>
            </condition>
            <shared_code>
              <value><![CDATA[#include "ch.h"

static semaphore_t sem1;]]></value>
            </shared_code>
            <cases>
              <case>
                <brief>
                  <value>Semaphore primitives, no state change.</value>
                </brief>
                <description>
                  <value>Wait, Signal and Reset primitives are tested. The testing thread does not trigger a state change.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chSemObjectInit(&sem1, 1);]]></value>
                  </setup_code>
                  <teardown_code>
                    <value><![CDATA[chSemReset(&sem1, 0);]]></value>
                  </teardown_code>
                  <local_variables>
                    <value />
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>The function chSemWait() is invoked, after return the counter and the returned message are tested.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[msg_t msg;

msg = chSemWait(&sem1);
test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
test_assert(MSG_OK == msg, "wrong returned message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The function chSemSignal() is invoked, after return the counter is tested.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chSemSignal(&sem1);
test_assert_lock(chSemGetCounterI(&sem1) == 1, "wrong counter value");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The function chSemReset() is invoked, after return the counter is tested.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chSemReset(&sem1, 2);
test_assert_lock(chSemGetCounterI(&sem1) == 2, "wrong counter value");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Semaphore primitives, with state change.</value>
                </brief>
                <description>
                  <value>Wait, Signal and Reset primitives are tested. The testing thread triggers a state change.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chSemObjectInit(&gsem1, 0);]]></value>
                  </setup_code>
                  <teardown_code>
                    <value><![CDATA[chSemReset(&gsem1, 0);]]></value>
                  </teardown_code>
                  <local_variables>
                    <value />
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>The function chSemWait() is invoked, after return the counter and the returned message are tested. The semaphore is signaled by another thread.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[msg_t msg;

msg = chSemWait(&gsem1);
test_assert_lock(chSemGetCounterI(&gsem1) == 0, "wrong counter value");
test_assert(MSG_OK == msg, "wrong returned message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The function chSemWait() is invoked, after return the counter and the returned message are tested. The semaphore is reset by another thread.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[msg_t msg;

msg = chSemWait(&gsem2);
test_assert_lock(chSemGetCounterI(&gsem2) == 0,"wrong counter value");
test_assert(MSG_RESET == msg, "wrong returned message");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Semaphores timeout.</value>
                </brief>
                <description>
                  <value>Timeout on semaphores is tested.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chSemObjectInit(&sem1, 0);]]></value>
                  </setup_code>
                  <teardown_code>
                    <value><![CDATA[chSemReset(&sem1, 0);]]></value>
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[systime_t time;
msg_t msg;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>The function chSemWaitTimeout() is invoked a first time, after return the system time, the counter and the returned message are tested.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
msg = chSemWaitTimeout(&sem1, MS2ST(1000));
test_assert_time_window(time + MS2ST(1000),
                        time + MS2ST(1000) + 1,
                        "out of time window");
test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
test_assert(MSG_TIMEOUT == msg, "wrong timeout message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The function chSemWaitTimeout() is invoked again, after return the system time, the counter and the returned message are tested.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
msg = chSemWaitTimeout(&sem1, MS2ST(1000));
test_assert_time_window(time + MS2ST(1000),
                        time + MS2ST(1000) + 1,
                        "out of time window");
test_assert_lock(chSemGetCounterI(&sem1) == 0, "wrong counter value");
test_assert(MSG_TIMEOUT == msg, "wrong timeout message");]]></value>

                  </step>
                </steps>
              </case>
            </cases>
          </sequence>
          <sequence>
            <type index="0">
              <value>Internal Tests</value>
            </type>
            <brief>
              <value>Suspend/Resume and Event Flags.</value>
            </brief>
            <description>
              <value>This sequence tests the ChibiOS/NIL functionalities related to threads suspend/resume and event flags.</value>
            </description>
            <condition>
              <value />
            </condition>
            <shared_code>
              <value><![CDATA[static thread_reference_t tr1;]]></value>
            </shared_code>
            <cases>
              <case>
                <brief>
                  <value>Suspend and Resume functionality.</value>
                </brief>
                <description>
                  <value>The functionality of chThdSuspendTimeoutS() and chThdResumeI() is tested.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[tr1 = NULL;]]></value>
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[systime_t time;
msg_t msg;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>The function chThdSuspendTimeoutS() is invoked, the thread is remotely resumed with message @p MSG_OK. On return the message and the state of the reference are tested.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chSysLock();
msg = chThdSuspendTimeoutS(&gtr1, TIME_INFINITE);
chSysUnlock();
test_assert(NULL == gtr1, "not NULL");
test_assert(MSG_OK == msg,"wrong returned message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The function chThdSuspendTimeoutS() is invoked, the thread is not resumed so a timeout must occur. On return the message and the state of the reference are tested.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chSysLock();
time = chVTGetSystemTimeX();
msg = chThdSuspendTimeoutS(&tr1, MS2ST(1000));
chSysUnlock();
test_assert_time_window(time + MS2ST(1000),
                        time + MS2ST(1000) + 1,
                        "out of time window");
test_assert(NULL == tr1, "not NULL");
test_assert(MSG_TIMEOUT == msg, "wrong returned message");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Events Flags functionality.</value>
                </brief>
                <description>
                  <value>Event flags functionality is tested.</value>
                </description>
                <condition>
                  <value>CH_CFG_USE_EVENTS</value>
                </condition>
                <various_code>
                  <setup_code>
                    <value />
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[systime_t time;
eventmask_t events;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>A set of event flags are set on the current thread then the function chEvtWaitAnyTimeout() is invoked, the function is supposed to return immediately because the event flags are already pending, after return the events mask is tested.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
chEvtSignal(chThdGetSelfX(), 0x55);
events = chEvtWaitAnyTimeout(ALL_EVENTS, MS2ST(1000));
test_assert((eventmask_t)0 != events, "timed out");
test_assert((eventmask_t)0x55 == events, "wrong events mask");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The pending event flags mask is cleared then the function chEvtWaitAnyTimeout() is invoked, after return the events mask is tested. The thread is signaled by another thread.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
chThdGetSelfX()->epmask = 0;
events = chEvtWaitAnyTimeout(ALL_EVENTS, MS2ST(1000));
test_assert((eventmask_t)0 != events, "timed out");
test_assert((eventmask_t)0x55 == events, "wrong events mask");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>The function chEvtWaitAnyTimeout() is invoked, no event can wakeup the thread, the function must return because timeout.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[time = chVTGetSystemTimeX();
events = chEvtWaitAnyTimeout(0, MS2ST(1000));
test_assert_time_window(time + MS2ST(1000),
                        time + MS2ST(1000) + 1,
                        "out of time window");
test_assert((eventmask_t)0 == events, "wrong events mask");]]></value>

                  </step>
                </steps>
              </case>
            </cases>
          </sequence>
          <sequence>
            <type index="0">
              <value>Internal Tests</value>
            </type>
            <brief>
              <value>Mailboxes.</value>
            </brief>
            <description>
              <value>This sequence tests the ChibiOS/NIL functionalities related to mailboxes.</value>
            </description>
            <condition>
              <value>CH_CFG_USE_MAILBOXES</value>
            </condition>
            <shared_code>
              <value><![CDATA[#define ALLOWED_DELAY MS2ST(5)
#define MB_SIZE 4

static msg_t mb_buffer[MB_SIZE];
static MAILBOX_DECL(mb1, mb_buffer, MB_SIZE);]]></value>
            </shared_code>
            <cases>
              <case>
                <brief>
                  <value>Mailbox normal API, non-blocking tests.</value>
                </brief>
                <description>
                  <value>The mailbox normal API is tested without triggering blocking conditions.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chMBObjectInit(&mb1, mb_buffer, MB_SIZE);]]></value>
                  </setup_code>
                  <teardown_code>
                    <value><![CDATA[chMBReset(&mb1);]]></value>
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[msg_t msg1, msg2;
unsigned i;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Testing the mailbox size.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Resetting the mailbox, conditions are checked, no errors expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chMBReset(&mb1);
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing the behavior of API when the mailbox is in reset state then return in active state.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[msg1 = chMBPost(&mb1, (msg_t)0, TIME_INFINITE);
test_assert(msg1 == MSG_RESET, "not in reset state");
msg1 = chMBPostAhead(&mb1, (msg_t)0, TIME_INFINITE);
test_assert(msg1 == MSG_RESET, "not in reset state");
msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_RESET, "not in reset state");
chMBResumeX(&mb1);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Filling the mailbox using chMBPost() and chMBPostAhead() once, no errors expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MB_SIZE - 1; i++) {
  msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
  test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
msg1 = chMBPostAhead(&mb1, 'A', TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing intermediate conditions. Data pointers must be aligned, semaphore counters are checked.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert_lock(chMBGetFreeCountI(&mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not full");
test_assert_lock(mb1.rdptr == mb1.wrptr, "pointers not aligned");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Emptying the mailbox using chMBFetch(), no errors expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MB_SIZE; i++) {
  msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE);
  test_assert(msg1 == MSG_OK, "wrong wake-up message");
  test_emit_token(msg2);
}
test_assert_sequence("ABCD", "wrong get sequence");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Posting and then fetching one more message, no errors expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing final conditions. Data pointers must be aligned to buffer start, semaphore counters are checked.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Mailbox I-Class API, non-blocking tests.</value>
                </brief>
                <description>
                  <value>The mailbox I-Class API is tested without triggering blocking conditions.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chMBObjectInit(&mb1, mb_buffer, MB_SIZE);]]></value>
                  </setup_code>
                  <teardown_code>
                    <value><![CDATA[chMBReset(&mb1);]]></value>
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[msg_t msg1, msg2;
unsigned i;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Testing the mailbox size.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "wrong size");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Resetting the mailbox, conditions are checked, no errors expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chSysLock();
chMBResetI(&mb1);
chSysUnlock();
test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert_lock(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert_lock(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");
chMBResumeX(&mb1);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Filling the mailbox using chMBPostI() and chMBPostAheadI() once, no errors expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MB_SIZE - 1; i++) {
  chSysLock();
  msg1 = chMBPostI(&mb1, 'B' + i);
  chSysUnlock();
  test_assert(msg1 == MSG_OK, "wrong wake-up message");
}
chSysLock();
msg1 = chMBPostAheadI(&mb1, 'A');
chSysUnlock();
test_assert(msg1 == MSG_OK, "wrong wake-up message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing intermediate conditions. Data pointers must be aligned, semaphore counters are checked.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert_lock(chMBGetFreeCountI(&mb1) == 0, "still empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == MB_SIZE, "not full");
test_assert_lock(mb1.rdptr == mb1.wrptr, "pointers not aligned");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Emptying the mailbox using chMBFetchI(), no errors expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MB_SIZE; i++) {
  chSysLock();
  msg1 = chMBFetchI(&mb1, &msg2);
  chSysUnlock();
  test_assert(msg1 == MSG_OK, "wrong wake-up message");
  test_emit_token(msg2);
}
test_assert_sequence("ABCD", "wrong get sequence");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Posting and then fetching one more message, no errors expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");
msg1 = chMBFetch(&mb1, &msg2, TIME_INFINITE);
test_assert(msg1 == MSG_OK, "wrong wake-up message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing final conditions. Data pointers must be aligned to buffer start, semaphore counters are checked.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert_lock(chMBGetFreeCountI(&mb1) == MB_SIZE, "not empty");
test_assert_lock(chMBGetUsedCountI(&mb1) == 0, "still full");
test_assert(mb1.buffer == mb1.wrptr, "write pointer not aligned to base");
test_assert(mb1.buffer == mb1.rdptr, "read pointer not aligned to base");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Mailbox timeouts.</value>
                </brief>
                <description>
                  <value>The mailbox API is tested for timeouts.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chMBObjectInit(&mb1, mb_buffer, MB_SIZE);]]></value>
                  </setup_code>
                  <teardown_code>
                    <value><![CDATA[chMBReset(&mb1);]]></value>
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[msg_t msg1, msg2;
unsigned i;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Filling the mailbox.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MB_SIZE; i++) {
  msg1 = chMBPost(&mb1, 'B' + i, TIME_INFINITE);
  test_assert(msg1 == MSG_OK, "wrong wake-up message");
}]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing chMBPost(), chMBPostI(), chMBPostAhead() and chMBPostAheadI() timeout.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[msg1 = chMBPost(&mb1, 'X', 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBPostI(&mb1, 'X');
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
msg1 = chMBPostAhead(&mb1, 'X', 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBPostAheadI(&mb1, 'X');
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Resetting the mailbox.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chMBReset(&mb1);;
chMBResumeX(&mb1);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing chMBFetch() and chMBFetchI() timeout.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[msg1 = chMBFetch(&mb1, &msg2, 1);
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");
chSysLock();
msg1 = chMBFetchI(&mb1, &msg2);
chSysUnlock();
test_assert(msg1 == MSG_TIMEOUT, "wrong wake-up message");]]></value>

                  </step>
                </steps>
              </case>
            </cases>
          </sequence>
          <sequence>
            <type index="0">
              <value>Internal Tests</value>
            </type>
            <brief>
              <value>Memory Pools.</value>
            </brief>
            <description>
              <value>This sequence tests the ChibiOS/NIL functionalities related to memory pools.</value>
            </description>
            <condition>
              <value>CH_CFG_USE_MEMPOOLS</value>
            </condition>
            <shared_code>
              <value><![CDATA[#define MEMORY_POOL_SIZE 4

static uint32_t objects[MEMORY_POOL_SIZE];
static MEMORYPOOL_DECL(mp1, sizeof (uint32_t), NULL);

#if CH_CFG_USE_SEMAPHORES
static GUARDEDMEMORYPOOL_DECL(gmp1, sizeof (uint32_t));
#endif

static void *null_provider(size_t size, unsigned align) {

  (void)size;
  (void)align;

  return NULL;
}]]></value>
            </shared_code>
            <cases>
              <case>
                <brief>
                  <value>Loading and emptying a memory pool.</value>
                </brief>
                <description>
                  <value>The memory pool functionality is tested by loading and emptying it, all conditions are tested.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chPoolObjectInit(&mp1, sizeof (uint32_t), NULL);]]></value>
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[unsigned i;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Adding the objects to the pool using chPoolLoadArray().</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chPoolLoadArray(&mp1, objects, MEMORY_POOL_SIZE);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Emptying the pool using chPoolAlloc().</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MEMORY_POOL_SIZE; i++)
  test_assert(chPoolAlloc(&mp1) != NULL, "list empty");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Now must be empty.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert(chPoolAlloc(&mp1) == NULL, "list not empty");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Adding the objects to the pool using chPoolFree().</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MEMORY_POOL_SIZE; i++)
  chPoolFree(&mp1, &objects[i]);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Emptying the pool using chPoolAlloc() again.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MEMORY_POOL_SIZE; i++)
  test_assert(chPoolAlloc(&mp1) != NULL, "list empty");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Now must be empty again.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert(chPoolAlloc(&mp1) == NULL, "list not empty");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Covering the case where a provider is unable to return more memory.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chPoolObjectInit(&mp1, sizeof (uint32_t), null_provider);
test_assert(chPoolAlloc(&mp1) == NULL, "provider returned memory");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Loading and emptying a guarded memory pool without waiting.</value>
                </brief>
                <description>
                  <value>The memory pool functionality is tested by loading and emptying it, all conditions are tested.</value>
                </description>
                <condition>
                  <value>CH_CFG_USE_SEMAPHORES</value>
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chGuardedPoolObjectInit(&gmp1, sizeof (uint32_t));]]></value>
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[unsigned i;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Adding the objects to the pool using chGuardedPoolLoadArray().</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[chGuardedPoolLoadArray(&gmp1, objects, MEMORY_POOL_SIZE);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Emptying the pool using chGuardedPoolAllocTimeout().</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MEMORY_POOL_SIZE; i++)
  test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) != NULL, "list empty");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Now must be empty.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) == NULL, "list not empty");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Adding the objects to the pool using chGuardedPoolFree().</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MEMORY_POOL_SIZE; i++)
  chGuardedPoolFree(&gmp1, &objects[i]);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Emptying the pool using chGuardedPoolAllocTimeout() again.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[for (i = 0; i < MEMORY_POOL_SIZE; i++)
  test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) != NULL, "list empty");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Now must be empty again.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert(chGuardedPoolAllocTimeout(&gmp1, TIME_IMMEDIATE) == NULL, "list not empty");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Guarded Memory Pools timeout.</value>
                </brief>
                <description>
                  <value>The timeout features for the Guarded Memory Pools is tested.</value>
                </description>
                <condition>
                  <value>CH_CFG_USE_SEMAPHORES</value>
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chGuardedPoolObjectInit(&gmp1, sizeof (uint32_t));]]></value>
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value />
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Trying to allocate with 100mS timeout, must fail because the pool is empty.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert(chGuardedPoolAllocTimeout(&gmp1, MS2ST(100)) == NULL, "list not empty");]]></value>

                  </step>
                </steps>
              </case>
            </cases>
          </sequence>
          <sequence>
            <type index="0">
              <value>Internal Tests</value>
            </type>
            <brief>
              <value>Memory Heaps.</value>
            </brief>
            <description>
              <value>This sequence tests the ChibiOS/NIL functionalities related to memory heaps.</value>
            </description>
            <condition>
              <value>CH_CFG_USE_HEAP</value>
            </condition>
            <shared_code>
              <value><![CDATA[#define ALLOC_SIZE 16
#define HEAP_SIZE (ALLOC_SIZE * 8)

static memory_heap_t test_heap;
static CH_HEAP_AREA(myheap, HEAP_SIZE);]]></value>
            </shared_code>
            <cases>
              <case>
                <brief>
                  <value>Allocation and fragmentation.</value>
                </brief>
                <description>
                  <value>Series of allocations/deallocations are performed in carefully designed sequences in order to stimulate all the possible code paths inside the allocator. The test expects to find the heap back to the initial status after each sequence.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value><![CDATA[chHeapObjectInit(&test_heap, myheap, sizeof(myheap));]]></value>
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[void *p1, *p2, *p3;
size_t n, sz;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Testing initial conditions, the heap must not be fragmented and one free block present.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert(chHeapStatus(&test_heap, &sz, NULL) == 1, "heap fragmented");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Trying to allocate an block bigger than available space, an error is expected.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[p1 = chHeapAlloc(&test_heap, HEAP_SIZE * 2);
test_assert(p1 == NULL, "allocation not failed");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Single block allocation using chHeapAlloc() then the block is freed using chHeapFree(), must not fail.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
test_assert(p1 != NULL, "allocation failed");
chHeapFree(p1);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Using chHeapStatus() to assess the heap state. There must be at least one free block of sufficient size.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[size_t total_size, largest_size;

n = chHeapStatus(&test_heap, &total_size, &largest_size);
test_assert(n == 1, "missing free block");
test_assert(total_size >= ALLOC_SIZE, "unexpected heap state");
test_assert(total_size == largest_size, "unexpected heap state");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Allocating then freeing in the same order.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
p2 = chHeapAlloc(&test_heap, ALLOC_SIZE);
p3 = chHeapAlloc(&test_heap, ALLOC_SIZE);
chHeapFree(p1);                                 /* Does not merge.*/
chHeapFree(p2);                                 /* Merges backward.*/
chHeapFree(p3);                                 /* Merges both sides.*/
test_assert(chHeapStatus(&test_heap, &n, NULL) == 1, "heap fragmented");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Allocating then freeing in reverse order.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
p2 = chHeapAlloc(&test_heap, ALLOC_SIZE);
p3 = chHeapAlloc(&test_heap, ALLOC_SIZE);
chHeapFree(p3);                                 /* Merges forward.*/
chHeapFree(p2);                                 /* Merges forward.*/
chHeapFree(p1);                                 /* Merges forward.*/
test_assert(chHeapStatus(&test_heap, &n, NULL) == 1, "heap fragmented");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Small fragments handling. Checking the behavior when allocating blocks with size not multiple of alignment unit.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[p1 = chHeapAlloc(&test_heap, ALLOC_SIZE + 1);
p2 = chHeapAlloc(&test_heap, ALLOC_SIZE);
chHeapFree(p1);
test_assert(chHeapStatus(&test_heap, &n, NULL) == 2, "invalid state");
p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
/* Note, the first situation happens when the alignment size is smaller
   than the header size, the second in the other cases.*/
test_assert((chHeapStatus(&test_heap, &n, NULL) == 1) ||
            (chHeapStatus(&test_heap, &n, NULL) == 2), "heap fragmented");
chHeapFree(p2);
chHeapFree(p1);
test_assert(chHeapStatus(&test_heap, &n, NULL) == 1, "heap fragmented");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Skipping a fragment, the first fragment in the list is too small so the allocator must pick the second one.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
p2 = chHeapAlloc(&test_heap, ALLOC_SIZE);
chHeapFree(p1);
test_assert( chHeapStatus(&test_heap, &n, NULL) == 2, "invalid state");
p1 = chHeapAlloc(&test_heap, ALLOC_SIZE * 2); /* Skips first fragment.*/
chHeapFree(p1);
chHeapFree(p2);
test_assert(chHeapStatus(&test_heap, &n, NULL) == 1, "heap fragmented");]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Allocating the whole available space.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[(void)chHeapStatus(&test_heap, &n, NULL);
p1 = chHeapAlloc(&test_heap, n);
test_assert(p1 != NULL, "allocation failed");
test_assert(chHeapStatus(&test_heap, NULL, NULL) == 0, "not empty");
chHeapFree(p1);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing final conditions. The heap geometry must be the same than the one registered at beginning.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[test_assert(chHeapStatus(&test_heap, &n, NULL) == 1, "heap fragmented");
test_assert(n == sz, "size changed");]]></value>

                  </step>
                </steps>
              </case>
              <case>
                <brief>
                  <value>Default Heap.</value>
                </brief>
                <description>
                  <value>The default heap is pre-allocated in the system. We test base functionality.</value>
                </description>
                <condition>
                  <value />
                </condition>
                <various_code>
                  <setup_code>
                    <value />
                  </setup_code>
                  <teardown_code>
                    <value />
                  </teardown_code>
                  <local_variables>
                    <value><![CDATA[void *p1;
size_t total_size, largest_size;]]></value>
                  </local_variables>
                </various_code>
                <steps>
                  <step>
                    <description>
                      <value>Single block allocation using chHeapAlloc() then the block is freed using chHeapFree(), must not fail.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[(void)chHeapStatus(NULL, &total_size, &largest_size);
p1 = chHeapAlloc(&test_heap, ALLOC_SIZE);
test_assert(p1 != NULL, "allocation failed");
chHeapFree(p1);]]></value>

                  </step>
                  <step>
                    <description>
                      <value>Testing allocation failure.</value>
                    </description>
                    <tags>
                      <value />
                    </tags>

                      <value><![CDATA[p1 = chHeapAlloc(NULL, (size_t)-256);
test_assert(p1 == NULL, "allocation not failed");]]></value>

                  </step>
                </steps>
              </case>
            </cases>
          </sequence>
        </sequences>
      </instance>
    </instances>
    <exportedFeatures />
  </application>
</SPC5-Config>


text:
package org.openntf.domino.tests.ntf;

import org.openntf.domino.Database;
import org.openntf.domino.Session;
import org.openntf.domino.utils.Factory;
import org.openntf.domino.utils.Factory.SessionType;
import org.openntf.domino.utils.TestRunnerUtil;

public class ServerPathTest implements Runnable {
	private long marktime;

	public static void main(final String[] args) {
		TestRunnerUtil.runAsDominoThread(new ServerPathTest(), TestRunnerUtil.NATIVE_SESSION);
	}

	public void timelog(final String message) {
		long curtime = System.nanoTime();
		long elapsed = curtime - marktime;
		marktime = curtime;
		System.out.println(elapsed / 1000000 + " ms: " + message);
	}

	public ServerPathTest() {
		// whatever you might want to do in your constructor, but stay away from Domino objects
	}

	@Override
	public void run() {
		Session session = Factory.getSession(SessionType.FULL_ACCESS);
		Database db = session.getDatabase("CN=Avatar/O=REDPILL", "log.nsf");
		System.out.println(db.getApiPath());
	}

}

redpajama_set_name: RedPajamaGithub


text:
from __future__ import unicode_literals

from django.conf import settings
from django.db import models
from django.utils.translation import ugettext_lazy as _
from model_utils.models import TimeStampedModel

class YubicoOTPDeviceQuerySet(models.QuerySet):
    def for_user(self, user):
        return self.filter(user=user)

class YubicoOTPDevice(TimeStampedModel):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    device_id = models.CharField(max_length=12, verbose_name=_("Device ID"))
    device_name = models.CharField(max_length=25,
                                   default=_("Yubico Token"),
                                   verbose_name=_("Device name"),
                                   help_text=_("Affordable user name token"))
    last_used = models.DateTimeField(null=True, blank=True, verbose_name=_("Last used"),
                                     help_text=_("Time of last use of the token"))
    objects = YubicoOTPDeviceQuerySet.as_manager()

    class Meta:
        verbose_name = _("Yubico OTP Device")
        verbose_name_plural = _("Yubico OTP Devices")
        ordering = ['created', ]

    def __str__(self):
        return _("Yubico OTP Device [{}]").format(self.device_id)


text:
module.exports = {
    css: { extract: false }
}


text:
The images used in Total Briecall are listed below with their associated licenses.

### General Images `/assets/images` ###
**hero.jpg** is licensed under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/) by TeraLogics
* It has been altered to be a sufficient landing-page background from [Genussmarkt Pur Südtirol Meran](https://commons.wikimedia.org/wiki/File:Pur_Meran_2.tif) by [Bionom07](https://commons.wikimedia.org/wiki/User_talk:Bionom07), used under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/)

### Food Category Images `/assets/images/foodcategories` ###
**soy.jpg** is licensed under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/) by TeraLogics
* It has been resized and/or cropped from [Dried Tofu](https://commons.wikimedia.org/wiki/File:Driedtofu.JPG) by [Sltan](https://en.wikipedia.org/wiki/User:Sltan), used under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/)

**nut.jpg** is licensed under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/) by TeraLogics
* It has been resized and/or cropped from [Mandorle sgusciate/Shelled almonds](https://commons.wikimedia.org/wiki/File:Mandorle_sgusciate.jpg) by [Luigi Chiesa](https://commons.wikimedia.org/wiki/User:Luigi_Chiesa), used under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/)

**egg.jpg** is licensed under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/) by TeraLogics
* It has been resized and/or cropped from [Braunes Ei und Eierschale/Brown egg and eggshell](https://commons.wikimedia.org/wiki/File:Eggshell_001.jpg) by [H. Zell](https://commons.wikimedia.org/wiki/User:Llez), used under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/)

**dairy.jpg** is licensed under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/) by TeraLogics
* It has been resized and/or cropped from [Un coulommiers au lait cru/A Coulommiers cheese made from unpasteurised cow's milk](https://commons.wikimedia.org/wiki/File:Eggshell_001.jpg) by [Myrabella](https://commons.wikimedia.org/wiki/User:Myrabella), used under [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/)

**fruit.jpg** is licensed under [CC BY-SA 2.5](https://creativecommons.org/licenses/by-sa/2.5/) by TeraLogics
* It has been resized and/or cropped from [This image shows a whole and a cut lemon](https://commons.wikimedia.org/wiki/File:Lemon.jpg) by [André Karwath](https://commons.wikimedia.org/wiki/User:Aka), used under [CC BY-SA 2.5](https://creativecommons.org/licenses/by-sa/2.5/)

**dye.jpg** is in the public domain
* It has been resized and/or cropped from [Food Coloring Bottles](https://flic.kr/p/2AevUf) by [Larry Jacobsen](https://www.flickr.com/photos/ljguitar/), used under [CC BY 2.0](https://creativecommons.org/licenses/by/2.0/)

**spice.jpg** is in the public domain
* It has been resized and/or cropped from [Anhelo de Marruecos](https://flic.kr/p/eVqavv) by [Luz Adriana Villa](http://www.flickr.com/people/11599314@N00), used under [CC BY 2.0](https://creativecommons.org/licenses/by/2.0/)

**vegetable.jpg** is in the public domain
* It has been resized and/or cropped from [peppers](https://flic.kr/p/9QpaFy) by [Janine](http://www.flickr.com/people/62274271@N00), used under [CC BY 2.0](https://creativecommons.org/licenses/by/2.0/)

**gluten.jpg** is in the public domain

**supplement.jpg** is in the public domain

**meat.jpg** is in the public domain

**fish.jpg** is in the public domain


text:
using Newtonsoft.Json;

namespace WebApi.DependencyAnalyzer.Engine.Config
{
    public class ConfigItem : IConfigItem
    {
        public ConfigItem(
            string[] directories,
            string[] fileNamePatterns,
            string[] fileNamePatternsExclude,
            bool includeSubdirs,
            string[] textSearchPatterns,
            string[] textSearchPatternsExclude,
            string[] scanners)
        {
            Directories = directories;
            FileNamePatterns = fileNamePatterns;
            FileNamePatternsExclude = fileNamePatternsExclude;
            IncludeSubdirs = includeSubdirs;
            TextSearchPatterns = textSearchPatterns;
            TextSearchPatternsExclude = textSearchPatternsExclude;
            Scanners = scanners;
        }

        [JsonProperty("directories")]
        public string[] Directories { get; }

        [JsonProperty("fileNamePatterns")]
        public string[] FileNamePatterns { get; }

        [JsonProperty("fileNamePatternsExclude")]
        public string[] FileNamePatternsExclude { get; }

        [JsonProperty("includeSubdirs")]
        public bool IncludeSubdirs { get; }

        [JsonProperty("textSearchPatterns")]
        public string[] TextSearchPatterns { get; }

        [JsonProperty("textSearchPatternsExclude")]
        public string[] TextSearchPatternsExclude { get; }

        [JsonProperty("scanners")]
        public string[] Scanners { get; }
    }
}


text:
package org.aieonf.commons.security;

public interface ILoginListener {

	public enum LoginEvents{
		REGISTER,
		LOGIN,
		LOGOFF,
		NOT_FOUND,
	}

	public void notifyLoginEvent( LoginEvent event );
}


text:
FROM debian:stable-slim

# Install C++ compilers and other deps
# note that openjdk-11-jdk-headless is a dependency of the java extractor
RUN apt-get update && \
    apt-get install -y git clang-11 build-essential zip python3 openjdk-11-jdk-headless && \
    apt-get clean

# Create clang symlinks
RUN ln -s /usr/bin/clang-11 /usr/bin/clang && \
    ln -s /usr/bin/clang++-11 /usr/bin/clang++

RUN echo 'build --client_env=CC=/usr/bin/clang' >> ~/.bazelrc
RUN echo 'build --client_env=CXX=/usr/bin/clang++' >> ~/.bazelrc

# Extract the Kythe release archive to /kythe
COPY kythe/release/kythe-v*.tar.gz /tmp/
RUN tar --no-same-owner -xzf /tmp/kythe-v*.tar.gz && \
    mv kythe-v*/ /kythe && \
    rm /tmp/kythe-v*.tar.gz

# Tools and configuration
ADD kythe/extractors/bazel/extract.sh /kythe/
ADD kythe/extractors/bazel/bazel_wrapper.sh /kythe/
ADD kythe/release/base/fix_permissions.sh /kythe/

# Bazelisk
ADD external/com_github_bazelbuild_bazelisk/bazelisk_/bazelisk /kythe/

RUN mkdir -p /workspace
WORKDIR /workspace

# copied from gcr.io bazel image
# Store the Bazel outputs under /workspace so that the symlinks under bazel-bin
# (et al) are accessible to downstream build steps.
RUN echo 'startup --output_base=/workspace/.bazel' >> ~/.bazelrc

ENTRYPOINT ["/kythe/extract.sh"]


text:
package com.massivedisaster.location.utils;

import android.util.Log;

/**
 * Location utilities.
 */
public final class LocationUtils {

    /**
     * Private constructor to avoid user implement as a single instance instead of a Singleton.
     */
    private LocationUtils() {
    }

    /**
     * Verify if location are enable
     *
     * @param locationManager the location manager
     * @return True if location are enabled
     */
    public static boolean isLocationEnabled(android.location.LocationManager locationManager) {
        boolean gpsEnabled;
        boolean networkEnabled;

        try {
            gpsEnabled = locationManager.isProviderEnabled(android.location.LocationManager.GPS_PROVIDER);
            networkEnabled = locationManager.isProviderEnabled(android.location.LocationManager.NETWORK_PROVIDER);

            return !(!gpsEnabled && !networkEnabled);

        } catch (IllegalArgumentException ex) {
            Log.d(LocationUtils.class.getCanonicalName(), ex.toString());
        }

        return true;
    }

}


text:
A powerful kernel and operating system that operates on ROBLOX games. Open source and very secure, built by the community.

Good for games / projects that have to manage a lot of GUI's, Swift OS's simple user interface makes dealing with game GUI's a lot easier.

Totally free (yes I said that on purpose!)

# Difference between kernel and operating system
Swift is built upon a unique kernel, although we give it out with the operating system built over it, developers can use the Swift kernel to create their own modifications of it and/or use it in a more advanced fashion in projects.


text:
using Game;
using UnityEngine;

namespace UI.MenuWindows
{
    public class EscWindow : DefaultMenuWindow
    {
        private void Update()
        {
            if (Input.GetButtonDown("Menu"))
                GameMenu.SingletonInstance.CloseWindow();
        }

        public void ToMainMenu()
        {
            GameInfo.info.LoadMainMenu();
        }

        public void Quit()
        {
            GameInfo.info.Quit();
        }
    }
}


text:
/**
***  Qlik Sense Extension - Chord Diagram v1.00
***
***  Developped : by Matthieu BUREL
***
***  Version : 1.02
***
***  Follow me on Tweeter : @VizMatt
**/

define(["jquery", "./ChordDiagram-Properties", "./Library/d3.min", "./Library/chroma.min"], function($, properties, d3, chroma) {
  return {
       initialProperties : {
			version: 1.0,
			qHyperCubeDef : {
				qDimensions : [],
				qMeasures : [],
				qInitialDataFetch : [{
					qWidth : 3,
					qHeight : 500
				}]
			}
		},

		definition : properties,

		snapshot : {
			canTakeSnapshot : true
		},

//------------------------------------------------------------------------------ Rendering
        paint : function($element, layout) {
//			var qData 						= layout.qHyperCube.qDataPages[0];
//			var qMatrix 					= qData.qMatrix;
//			var qNomb_Row 					= layout.qHyperCube.qSize.qcx;
//			var qNomb_Col 					= layout.qHyperCube.qSize.qcy;
//			var qProperty_xxxx				= layout.ref;
//			var qProperty_Dim1Title 		= layout.qHyperCube.qDimensionInfo[0].qFallbackTitle;
//			var qProperty_Dim1Cardinality 	= layout.qHyperCube.qDimensionInfo[0].qCardinal;
//			var qProperty_Dim2Title 		= layout.qHyperCube.qDimensionInfo[1].qFallbackTitle;
//			var qProperty_Dim2Cardinality 	= layout.qHyperCube.qDimensionInfo[1].qCardinal;

			var self 			= this;
			var data 			= getBiDimensionnalMatrix(layout);
			var display 		= getDisplayArray($element);
			var dimension		= getDimensionArray($element, layout);
			var color 			= getColorArray(layout, chroma.interpolate.bezier(layout.ColorSchema.split(", ")));
			var scale 			= getScaleArray(data, display[1], layout.UnitsSystem.split(", "));
			var selection		= getSelectionMode(dimension);

			rendering(self, selection, data, display, dimension, color, scale, $element, layout);
		}
	};
});

//--------------------------------------------------------------------------------------------------------- D3.JS & Chroma.JS Library ---------------------------
function rendering(self, selection, matrix, display, dimension, fill, scale, $element, layout) {

	var id = "container_"+ layout.qInfo.qId;

	if (document.getElementById(id)) {
		$("#" + id).empty();
	}
	else {
		$element.append($('
').attr("id", id).width($element.width()).height($element.height()));
	}

	var chart_div = d3.select("#" + id);

	var chord = d3.layout.chord()
		.padding(.05)
		.sortSubgroups(d3.descending)
		.matrix(matrix);

	var width = $element.width();
	var height = $element.height();
	var innerRadius = Math.min(width, height) * display[0];
	var outerRadius = innerRadius + 16;
	var selections = layout.qHyperCube.qDimensionInfo[0].qStateCounts.qSelected;

    var svg = chart_div.append("svg")
		.attr("width",width)
		.attr("height",height)
		.append("g")
        .attr("transform", "translate(" + (width) / 2 + "," + (height) / 2 + ")");

	var numFormat = d3.format(',')

	if(document.getElementById("tooltip_" + id)) {
		$("#tooltip_" + id).empty();
		var tooltip = d3.select("#tooltip_" + id);
	} else {
		var tooltip = d3.select("body")
			.append("div")
			.attr("class","tooltip")
			.attr("id","tooltip_" +id);
	}

	tooltip
		.style("position", "absolute")
		.style("padding-top", "8px")
		.style("padding-bottom", "8px")
		.style("padding-left", "18px")
		.style("padding-right", "18px")
		.style("width", "160px")
		.style("color", "#FFFFFF")
		.style("background", "#000000")
		.style("line-height", "25px")
		.style("text-align", "left")
		.style("border-radius", "6px")
		.style("opacity", ".8");

    var chordGroup = svg.append("g").selectAll("path")
		.data(chord.groups)
		.enter().append("path")
        .style("fill", function(d) { return fill[d.index]; })
        .style("stroke", function(d) { return d3.rgb(fill[d.index]).darker(); })
      .attr("class","chord_path")
      .attr("id", function(d, i){return "group-" + i;})
        .attr("d", d3.svg.arc().innerRadius(innerRadius).outerRadius(outerRadius));

    svg.append("g")
        .attr("class", "chord")
      .selectAll("path")
        .data(chord.chords)
      .enter().append("path")
        .attr("d", d3.svg.chord().radius(innerRadius))
        .style("fill", function(d) { return fill[d.target.index]; })
        .style("stroke", function(d) { return d3.rgb(fill[d.target.index]).darker(); })
      .style("opacity", .5);

    svg.append("g").selectAll("text")
        .data(chord.groups)
      .enter().append("svg:text")
         .attr("class","text_label")
         .attr("x", ".60em")
         .attr("dy", "13px")
      .append("svg:textPath")
      .attr("xlink:href", function(d, i){return "#group-" + i;})
        .text(function(d,i) {
			return dimension[i][2];})
      .style("font-weight", "bold")
        .style("font-size", "13px")
      .style("font-family", "sans-serif")
      .style("fill", function(d, i) { return d3.rgb(fill[i]).darker().darker().darker(); });

    var user_click_area = d3.selectAll('.text_label,.chord_path');
    var clicked_nodes = [];

	user_click_area
		.on("click",
			function(d,i) {
				var cur_i = d.index;
				if(clicked_nodes.indexOf(cur_i)>-1) {
					clicked_nodes.splice(clicked_nodes.indexOf(cur_i));
				} else {
					clicked_nodes.push(cur_i);
				}

				user_click_area.on("mouseover",function(d,i) {
					tooltip.style("visibility", "visible")
					.html(""+ dimension[d.index][0] + '
Total:  ' + numFormat(dimension[d.index][1]) + "");
				});
				user_click_area.on("mouseout",function(d,i) {
					tooltip.style("visibility", "hidden")
					.html(""+ dimension[d.index][0] + '
Total:  ' + numFormat(dimension[d.index][1]) + "");
				});

				if (selection == 1) {
					self.selectValues(0, [dimension[i][5]], true);
					self.backendApi.selectValues(1, [dimension[i][6]], true);
					svg.selectAll(".chord path").transition().style("opacity", .3);
					svg.selectAll(".chord path").filter(function(d) { return clicked_nodes.indexOf(d.source.index)>-1 ; }).transition().style("opacity", .4);
					svg.selectAll(".chord path").filter(function(d) { return clicked_nodes.indexOf(d.target.index)>-1 ; }).transition().style("opacity", .4);
					svg.selectAll(".chord path").filter(function(d) { return clicked_nodes.indexOf(d.target.index)>-1  && clicked_nodes.indexOf(d.source.index)>-1 ; }).transition().style("opacity", 1);
				} else {
					self.backendApi.selectValues(0, [dimension[i][5]], true);
					self.backendApi.selectValues(1, [dimension[i][6]], true);
				}
			}
		)
		.on("mouseover",
			function(d,i){
				var cur_i = d.index;
				svg.selectAll(".chord path").filter(function(d) { return d.target.index != cur_i && d.source.index != cur_i; }).transition().style("opacity", .2);
				tooltip.style("visibility", "visible")
				.html(""+ dimension[d.index][0] + '
Total:  ' + numFormat(dimension[d.index][1]) + "");})
		.on("mousemove",
			function(d,i){
				tooltip.style("top", (event.pageY-10)+"px").style("left",(event.pageX+10)+"px")
				.html(""+ dimension[d.index][0] + '
Total:  ' + numFormat(dimension[d.index][1]) + "");})
		.on("mouseout",
			function(d,i){
				var cur_i = d.index;
				svg.selectAll(".chord path").filter(function(d) { return d.target.index != cur_i && d.source.index != cur_i; }).transition().style("opacity", .5);
				tooltip.style("visibility", "hidden")
				.html(""+ dimension[d.index][0] + '
Total:  ' + numFormat(dimension[d.index][1]) + "");});

		var ticks = svg.append("g").selectAll("g")
				.data(chord.groups)
			.enter().append("g").selectAll("g")
				.data(groupTicks)
			.enter().append("g")
				.attr("transform", function(d) {
					return "rotate(" + (d.angle * 180 / Math.PI - 90) + ")"
					+ "translate(" + (outerRadius) + ",0)";
				});

    ticks.append("line")
        .attr("x1", 1)
        .attr("y1", 0)
        .attr("x2", 5)
        .attr("y2", 0)
        .style("stroke", "#000");

    ticks.append("text")
        .attr("x", 8)
        .attr("dy", ".50em")
        .attr("transform", function(d) { return d.angle > Math.PI ? "rotate(180)translate(-16)" : null; })
        .style("text-anchor", function(d) { return d.angle > Math.PI ? "end" : null; })
        .text(function(d) { return d.label ; })
      .style("font-size",display[2]);

  function groupTicks(d) {
    var k = (d.endAngle - d.startAngle) / d.value;
    return d3.range(0, d.value, scale[1]*scale[0]).map(function(v, i) {
      return {
      angle: v * k + d.startAngle,
      label: i % 1 ? null : Math.round(v / scale[0]) + scale[2]
      };
    });
  }
}

//--------------------------------------------------------------------------------------------------------- Custom Data function --------------------------------
// Returns a variable representing the sum of all values in the array / matrix
function getSumArray(inputMatrix) {
	var outputVariable = d3.sum(inputMatrix, function(array) {
		return d3.sum(array, Number);
	});
	return outputVariable;
}

// Returns a variable representing the min value in the array / matrix
function getMinArray(inputMatrix) {
	var outputVariable = d3.min(inputMatrix, function(array) {
		return d3.min(array, Number);
	});
	return outputVariable;
}

// Returns a variable representing the max value in the array / matrix
function getMaxArray(inputMatrix) {
	var outputVariable = d3.max(inputMatrix, function(array) {
		return d3.max(array, Number);
	});
	return outputVariable;
}

// Returns an array of distinct value
function getUniqueDimension(inputLayout) {
	var inputMatrix = inputLayout.qHyperCube.qDataPages[0].qMatrix;
	var inputMatrixSize = inputLayout.qHyperCube.qSize.qcy;
	var inputArray = [];
	var outputArray = [];

	for (k = 0; k < inputMatrixSize; k++) {
		if(inputMatrix[k] != null && inputMatrix[k].length > 0) {
			var i = 2 * k;
			var j = i + 1;
			inputArray[i] = inputMatrix[k][0].qText;
			inputArray[j] = inputMatrix[k][1].qText;
		}
	}

	for (var i = 0; i < inputArray.length; i++){
		if ((jQuery.inArray(inputArray[i], outputArray)) == -1){
			outputArray.push(inputArray[i]);
		}
	}

	return outputArray;
}

// Returns an array of dimension properties
function getDimensionProperty(inputLayout) {
	var inputMatrix = inputLayout.qHyperCube.qDataPages[0].qMatrix;
	var inputMatrixSize = inputLayout.qHyperCube.qSize.qcy;
	var inputProperty = [], intermediateProperty = [], outputArray = [];
	var inputProperty_Dim1a = [], inputProperty_Dim1b = [], inputProperty_Dim1c = [], inputProperty_Dim2a = [], inputProperty_Dim2b = [], inputProperty_Dim2c = [];

	for (k = 0; k < inputMatrixSize; k++) {
		if(inputMatrix[k] != null && inputMatrix[k].length > 0) {
			var i = 2 * k;
			var j = i + 1;
			inputProperty[i] = inputMatrix[k][0].qText;
			inputProperty[j] = inputMatrix[k][1].qText;
			inputProperty_Dim1a[k] = inputMatrix[k][0].qText;
			inputProperty_Dim1b[k] = 1;
			inputProperty_Dim1c[k] = inputMatrix[k][0].qElemNumber;
			inputProperty_Dim2a[k] = inputMatrix[k][1].qText;
			inputProperty_Dim2b[k] = 2;
			inputProperty_Dim2c[k] = inputMatrix[k][1].qElemNumber;
		}
	}

	for (i = 0; i < inputProperty.length; i++){
		if ((jQuery.inArray(inputProperty[i], intermediateProperty)) == -1){
			intermediateProperty.push(inputProperty[i]);
		}
	}

	for (i = 0; i < intermediateProperty.length; i++){
		var currentDim = intermediateProperty[i], test_Dim1, test_Dim2, id_Dim1, id_Dim2;
		if (inputProperty_Dim1b[inputProperty_Dim1a.indexOf(currentDim)] == 1) { test_Dim1 = 1; } else { test_Dim1 = 0; };
		if (inputProperty_Dim2b[inputProperty_Dim2a.indexOf(currentDim)] == 2) { test_Dim2 = 1; } else { test_Dim2 = 0; };
		var test_Dim = test_Dim2 - test_Dim1;
		if (inputProperty_Dim1c[inputProperty_Dim1a.indexOf(currentDim)] == null) { id_Dim1 = -1; } else { id_Dim1 = inputProperty_Dim1c[inputProperty_Dim1a.indexOf(currentDim)]; };
		if (inputProperty_Dim2c[inputProperty_Dim2a.indexOf(currentDim)] == null) { id_Dim2 = -1; } else { id_Dim2 = inputProperty_Dim2c[inputProperty_Dim2a.indexOf(currentDim)]; };
		outputArray[i] = new Array(4);
		outputArray[i][0] = currentDim;
		outputArray[i][1] = test_Dim;
		outputArray[i][2] = id_Dim1;
		outputArray[i][3] = id_Dim2;
	  }

	  return outputArray;
}

// Returns the selection mode used regarding the equivalence between both dimension
function getSelectionMode(inputDimension) {
	var dimensionality = 0, outputSelectionMode = 0;

	for (i = 0; i < inputDimension.length; i++) {
		dimensionality += Math.abs(inputDimension[i][4]);
	}
	if(dimensionality == 0) { outputSelectionMode = 1; } else { outputSelectionMode = 0; }

	return outputSelectionMode;
}

// Returns an array of 2 dimensions & 1 metric
function getBiDimensionnalTable(inputLayout) {
	var inputMatrix = inputLayout.qHyperCube.qDataPages[0].qMatrix;
	var inputMatrixSize = inputLayout.qHyperCube.qSize.qcy;
	var outputArray = [];

	for (i = 0; i < inputMatrixSize; i++) {
		outputArray[i]  = new Array(inputMatrixSize);
		outputArray[i][0] = inputMatrix[i][0].qText;
		outputArray[i][1] = inputMatrix[i][1].qText;
		outputArray[i][2] = inputMatrix[i][2].qNum;
	}

	return outputArray;
}

// Returns an bidimensionnal matrix
function getBiDimensionnalMatrix(inputLayout) {
	var inputMatrix = inputLayout.qHyperCube.qDataPages[0].qMatrix;
	var inputTable_DistinctDimension = getUniqueDimension(inputLayout);
	var inputVariable_DimensionsCardinality = inputLayout.qHyperCube.qSize.qcy;
	var inputVariable_outputMatrixSize = inputTable_DistinctDimension.length;
	var outputMatrix = new Array(inputVariable_outputMatrixSize);

	for (i = 0; i < inputVariable_outputMatrixSize; i++) {
		outputMatrix[i]= new Array(inputVariable_outputMatrixSize);
		for (j = 0; j < inputVariable_outputMatrixSize; j++) {
			outputMatrix[i][j] = 0;
		}
	}

	if(inputMatrix[i] != null && inputMatrix[i].length > 0) {
		for (i = 0; i < inputVariable_DimensionsCardinality; i++) {
			var x = inputTable_DistinctDimension.indexOf(inputMatrix[i][0].qText);
			var y = inputTable_DistinctDimension.indexOf(inputMatrix[i][1].qText);
			outputMatrix[x][y] = inputMatrix[i][2].qNum;
		}
	}

	return outputMatrix;
}

// Returns an array of color palette
function getColorArray(inputLayout, inputColorDefinition) {
	var outputArray = [0];
	var outputArray = [1, 1];
	var colorPaletteSize = getUniqueDimension(inputLayout);
	var colorPaletteStep = 1 / (colorPaletteSize.length - 1);
	for (i = 0; i < colorPaletteSize.length; i++) {
		outputArray[i] = inputColorDefinition(i * colorPaletteStep);
	}

	return outputArray;
}

// Returns an array of scale characteristics
function getScaleArray(data, scale_Number, units) {
	var outputArray = [], i = 0, j = 0;
	var scale_Template = [1, 2, 5, 10, 20, 25, 50, 75, 100, 250, 500];
	var segment_LowerBound = 0, segment_UpperBound = Math.round(getSumArray(data));
	var segment_Multiplier = Math.pow(10, (Math.floor((Math.ceil(Math.log(getSumArray(data) + 1) / Math.LN10)- 2) / 3) * 3));
	var segment_Division = (((segment_UpperBound - segment_LowerBound) / segment_Multiplier)  / scale_Number);
	outputArray[0] = segment_Multiplier;
	outputArray[1] = scale_Template[scale_Template.length - 1];

	for(i in scale_Template){
		var delta = segment_Division - scale_Template[i];
		if(delta < 0 && j == 0) {
			outputArray[1] = scale_Template[i]; j = 1;
		}
	}

	switch(Math.floor((Math.ceil(Math.log(getSumArray(data) + 1) / Math.LN10)- 2) / 3)) {
		case 0: outputArray[2] = ""; break;
		case 1: outputArray[2] = units[0]; break;
		case 2: outputArray[2] = units[1]; break;
		case 3: outputArray[2] = units[2]; break;
		case 4: outputArray[2] = units[3]; break;
		case 5: outputArray[2] = units[4]; break;
		case 6: outputArray[2] = units[5]; break;
		case 7: outputArray[2] = units[6]; break;
		case 8: outputArray[2] = units[7]; break;
		case 9: outputArray[2] = units[8]; break;
		default: outputArray[2] = ""; break;
	  }

	outputArray[3] = segment_Division;
	return outputArray;
}

// Returns an array of display characteristics
function getDisplayArray($element) {
	var display = [], size = Math.min($element.width(), $element.height());

	//Ref Size coefficient
		if (size > 400) { display[0] = .38; } else { display[0] = .28; }
	//Adjust segment division
		if (size > 300) { display[1] = 75; } else { display[1] = 20; }
	//Adjust size of indicator
		if (size > 350) { display[2] = "13px"; } else { display[2] = "11px"; }
		if (size < 250) { display[2] = "0px"; }

	return display;
}

// Returns an array of dimension to display
function getDimensionArray($element, layout) {
  if (Math.min($element.width(), $element.height()) > 400) { display = 1; } else { display = .75; }
  var data = getBiDimensionnalMatrix(layout);
  var dim = getUniqueDimension(layout);
  var prop = getDimensionProperty(layout);
  var circonf = Math.PI*(Math.min($element.width(), $element.height()) * 0.4 * display);
  var i, j = data.length, limit, result = [], wrap = " ", words = " ";

  for (i = 0; i < j; i++) {
    limit = Math.floor(((d3.sum(data[i]) / (getSumArray(data))*circonf)*.18));
    if(limit > 1 && Math.min($element.width(), $element.height()) > 200) {var words = dim[i].substring(0, limit)} else {var words = ""} ;
    result[i] = [dim[i], d3.sum(data[i]), words, limit, prop[i][1], prop[i][2], prop[i][3]];
  }

  return result;
}


text:
require 'mongoid/graph/version'
require 'mongoid/graph/node'
require 'mongoid/graph/link'
require 'array'

module Mongoid
  module Graph
    class NodeError < StandardError; end
    class LinkError < StandardError; end

    def self.dot nodes
      dot = "digraph g {\n"
      nodes.each do |source|
        source.endpoints(:out).each do |target|
          dot << "  #{source.label} -> #{target.label};\n"
        end
      end
      dot + '}'
    end

    def self.dagre nodes
      dagre = []
      nodes.each do |source|
        source.endpoints(:out).each do |target|
          dagre << {sourceId: source.id.to_s, source: source.label, targetId: target.id.to_s, target: target.label}
        end
      end
      dagre
    end

  end
end