Subversion Repositories fwrisc

/*

 * fwrisc_zephyr_tests.cpp

 *

 * Copyright 2018 Matthew Ballance

 *

 * Licensed under the Apache License, Version 2.0 (the

 * "License"); you may not use this file except in

 * compliance with the License.  You may obtain a copy of

 * the License at

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in

 * writing, software distributed under the License is

 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

 * CONDITIONS OF ANY KIND, either express or implied.  See

 * the License for the specific language governing

 * permissions and limitations under the License.

 *

 *

 *  Created on: Nov 16, 2018

 *      Author: ballance

 */

#include "fwrisc_zephyr_tests.h"

#include "ElfSymtabReader.h"

#include "GoogletestVlCmdlineProcessor.h"

#include <stdio.h>

fwrisc_zephyr_tests::fwrisc_zephyr_tests() : fwrisc_ctest_base(10000000) {

        m_ram_console = 0;

        m_raw_console = false;

        m_halt_addr = 0; // Don't halt

        m_msg_listener = [&](const std::string &msg) { }; // Empty

}

fwrisc_zephyr_tests::~fwrisc_zephyr_tests() {

        // TODO Auto-generated destructor stub

}

void fwrisc_zephyr_tests::SetUp() {

        fwrisc_ctest_base::SetUp();

        m_ram_console = m_symtab.find_sym("ram_console").st_value;

        // _Fault is called when the main function returns

        m_halt_addr = m_symtab.find_sym("_Fault").st_value;

        filter_func("char_out");

        filter_func("ram_console_out");

        filter_func("__udivsi3");

        filter_func("__umodsi3");

        filter_func("__mulsi3");

        fprintf(stdout, "Ram Console: 0x%08x\n", m_ram_console);

}

void fwrisc_zephyr_tests::regwrite(uint32_t raddr, uint32_t rdata) {

}

void fwrisc_zephyr_tests::exec(uint32_t addr, uint32_t instr) {

        fwrisc_ctest_base::exec(addr, instr);

//      std::string sym;

//      if (m_trace_funcs) {

//              if (m_symtab.find_sym(addr, sym)) {

//                      fprintf(stdout, "EXEC: %s (0x%08x)\n", sym.c_str(), addr);

//              }

//      }

//      if (m_trace_instr) {

//              fprintf(stdout, "EXEC: 0x%08x\n", addr);

//      }

//

//      if (addr == m_halt_addr) {

//              fprintf(stdout, "hit halt address 0x%08x\n", m_halt_addr);

//              m_end_of_test = true;

//              dropObjection(this);

//      }

}

void fwrisc_zephyr_tests::memwrite(uint32_t addr, uint8_t mask, uint32_t data) {

//      fprintf(stdout, "WRITE: 0x%08x\n", addr);

        if (addr >= m_ram_console && addr < (m_ram_console+1024)) {

                char ch;

                switch (mask) {

                case 1: ch = ((data >> 0) & 0xFF); break;

                case 2: ch = ((data >> 8) & 0xFF); break;

                case 4: ch = ((data >> 16) & 0xFF); break;

                case 8: ch = ((data >> 24) & 0xFF); break;

                }

                if (ch) {

                        if (m_raw_console) {

                                fputc(ch, stdout);

                                fflush(stdout);

                        }

                        if (ch == '\n') {

                                if (!m_raw_console) {

                                        fputs("# ", stdout);

                                        fputs(m_buffer.c_str(), stdout);

                                        fputs("\n", stdout);

                                        fflush(stdout);

                                }

                                m_msg_listener(m_buffer);

                                m_console_out.push_back(m_buffer);

                                m_buffer.clear();

                        } else {

                                m_buffer.push_back(ch);

                        }

                }

        }

}

void fwrisc_zephyr_tests::check(const char *exp[], uint32_t exp_sz) {

        ASSERT_EQ(m_end_of_test, true);

        for (uint32_t i=0; i<exp_sz; i++) {

                const char *msg = exp[i];

                bool found = false;

                for (std::vector<std::string>::const_iterator it=m_console_out.begin();

                                it!=m_console_out.end(); it++) {

                        std::string line = (*it);

                        if (line == msg) {

                                found = true;

                                break;

                        }

                }

                if (!found) {

                        fprintf(stdout, "Error: Failed to find msg \"%s\"\n", msg);

                }

                ASSERT_EQ(true, found);

        }

}

TEST_F(fwrisc_zephyr_tests, dhrystone) {

        const char *exp[] = {

                        "Hello World! fwrisc_sim"

        };

        m_msg_listener = [&](const std::string &msg) {

                if (msg == "Hello World! fwrisc_sim") {

                        m_end_of_test = true;

                        dropObjection(this);

                }

        };

        run(100000000);

        check(exp, sizeof(exp)/sizeof(const char *));

}

TEST_F(fwrisc_zephyr_tests, hello_world) {

        const char *exp[] = {

                        "Hello World! fwrisc_sim"

        };

        m_msg_listener = [&](const std::string &msg) {

                if (msg == "Hello World! fwrisc_sim") {

                        m_end_of_test = true;

                        dropObjection(this);

                }

        };

        run(100000);

        check(exp, sizeof(exp)/sizeof(const char *));

}

TEST_F(fwrisc_zephyr_tests, synchronization) {

        int threadB_count = 0;

        const char *exp[] = {

                        "threadA: Hello World from fwrisc_sim!",

                        "threadB: Hello World from fwrisc_sim!"

        };

        m_msg_listener = [&](const std::string &msg) {

                if (msg.substr(0, strlen("threadB")) == "threadB") {

                        threadB_count++;

                }

                if (threadB_count >= 2) {

                        m_end_of_test = true;

                        dropObjection(this);

                }

        };

        run(100000000);

        check(exp, sizeof(exp)/sizeof(const char *));

}

TEST_F(fwrisc_zephyr_tests, philosophers) {

        const char *exp[] = {

                        "An implementation of a solution to the Dining Philosophers"

        };

        m_raw_console = true;

        run(100000000);

        check(exp, sizeof(exp)/sizeof(const char *));

}

TEST_F(fwrisc_zephyr_tests, coretest) {

        run(100000);

        ASSERT_EQ(m_end_of_test, true);

}