def test_ridge_regression():
    stock_d = testdata()
    ti = TechnicalIndicators(stock_d)

    filename = "test_N225_ridge.pickle"
    clffile = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "clf", filename)

    if os.path.exists(clffile):
        os.remove(clffile)

    clf = Regression(filename)
    ti.calc_ret_index()
    ret = ti.stock["ret_index"]
    base = ti.stock_raw["Adj Close"][0]

    train_X, train_y = clf.train(ret, regression_type="Ridge")

    test_y = clf.predict(ret, base)

    expected = 19177.97
    r = round(test_y[0], 2)
    eq_(r, expected)

    if os.path.exists(clffile):
        os.remove(clffile)

def regression_chicago_crime_weather(p, date_start, date_end, crime_types = None, wards = None):
    crime_data = get_chicago_crime_data(p, date_start, date_end, crime_types, wards)
    weather_data = get_chicago_weather_data(p, date_start, date_end)

    crimes = [x[1] for x in crime_data]
    temps = [x[1] for x in weather_data]
    fill_missing_values(temps)
    
    r = Regression(temps, u"Temperature (°F)", crimes, get_crimes_label(crime_types))    
    r.compute()
    r.plot()

import sys
from regression import Regression

loader = sys.argv[1]

# Running udp
regression = Regression(loader, "udp", None)

regression.add_check(name="udp",
    check=lambda res:
      "Data: This is packet 0" in res[0].out and
      "Data: This is packet 1" in res[0].out and
      "Data: This is packet 2" in res[0].out and
      "Data: This is packet 3" in res[0].out and
      "Data: This is packet 4" in res[0].out and
      "Data: This is packet 5" in res[0].out and
      "Data: This is packet 6" in res[0].out and
      "Data: This is packet 7" in res[0].out and
      "Data: This is packet 8" in res[0].out and
      "Data: This is packet 9" in res[0].out)

rv = regression.run_checks()
if rv:
    sys.exit(rv)

import os, sys, mmap
from regression import Regression

loader = sys.argv[1]
sgx = os.environ.get('SGX_RUN') == '1'

# Running Bootstrap
regression = Regression(loader, "mmap-file", None, 60000)

regression.add_check(name="Private mmap beyond file range",
    check=lambda res: "mmap test 6 passed" in res[0].out and \
                      "mmap test 7 passed" in res[0].out)

regression.add_check(name="Private mmap beyond file range (after fork)",
    check=lambda res: "mmap test 1 passed" in res[0].out and \
                      "mmap test 2 passed" in res[0].out and \
                      "mmap test 3 passed" in res[0].out and \
                      "mmap test 4 passed" in res[0].out)

# On SGX, SIGBUS isn't always implemented correctly, for lack
# of memory protection.  For now, some of these cases won't work.
if not sgx:
    regression.add_check(name="SIGBUS test",
                         check=lambda res: "mmap test 5 passed" in res[0].out and \
                         "mmap test 8 passed" in res[0].out)


rv = regression.run_checks()
if rv: sys.exit(rv)

#!/usr/bin/python

import os, sys, mmap
from regression import Regression

loader = './pal'

# Running Bootstrap
regression = Regression(loader, "bootstrap")

regression.add_check(name="Basic Bootstrapping",
    check=lambda res: "User Program Started" in res[0].out)

regression.add_check(name="One Argument Given",
    check=lambda res: "# of Arguments: 1" in res[0].out and \
            "argv[0] = file:bootstrap" in res[0].out)

regression.add_check(name="Five Arguments Given",
    args = ['a', 'b', 'c', 'd'],
    check=lambda res: "# of Arguments: 5" in res[0].out and \
           "argv[0] = file:bootstrap" in res[0].out and \
           "argv[1] = a" in res[0].out and "argv[2] = b" in res[0].out and \
           "argv[3] = c" in res[0].out and "argv[4] = d" in res[0].out)

regression.run_checks()

import os, sys, mmap
from regression import Regression

loader = sys.argv[1]

# Running Bootstrap
regression = Regression(loader, "proc")

regression.add_check(name="Base /proc files present",
    check=lambda res: "/proc/1/.." in res[0].out and \
                      "/proc/1/cwd" in res[0].out and \
                      "/proc/1/exe" in res[0].out and \
                      "/proc/1/root" in res[0].out and \
                      "/proc/1/fd" in res[0].out and \
                      "/proc/1/maps" in res[0].out and \
                      "/proc/." in res[0].out and \
                      "/proc/1" in res[0].out and \
                      "/proc/self" in res[0].out and \
                      "/proc/meminfo" in res[0].out and \
                      "/proc/cpuinfo" in res[0].out)


rv = regression.run_checks()
if rv: sys.exit(rv)

import sys
from regression import Regression

loader = sys.argv[1]

# Running sigaltstack
regression = Regression(loader, "sigaltstack")

messages = (
    "OK on sigaltstack in main thread before alarm",
    "&act == 0x",
    "sig 14 count 1 goes off with sp=0x",
    "OK on signal stack",
    "OK on sigaltstack in handler",
    "sig 14 count 2 goes off with sp=0x",
    "OK on signal stack",
    "OK on sigaltstack in handler",
    "sig 14 count 3 goes off with sp=0x",
    "OK on signal stack",
    "OK on sigaltstack in handler",
    "OK on sigaltstack in main thread",
    "done exiting",
)

regression.add_check(name="Sigaltstack Test",
    check=lambda res: all([x in res[0].out for x in messages]))

rv = regression.run_checks()
if rv: sys.exit(rv)

import os, sys, mmap
from regression import Regression

loader = os.environ['PAL_LOADER']

regression = Regression(loader, "Pipe")

regression.add_check(name="Pipe Creation",
    check=lambda res: "Pipe Creation 1 OK" in res[0].log)

regression.add_check(name="Pipe Attributes",
    check=lambda res: "Pipe Attribute Query 1 on pipesrv returned OK" in res[0].log)

regression.add_check(name="Pipe Connection",
    check=lambda res: "Pipe Connection 1 OK" in res[0].log)

regression.add_check(name="Pipe Transmission",
    check=lambda res: "Pipe Write 1 OK" in res[0].log and
                      "Pipe Read 1: Hello World 1" in res[0].log and
                      "Pipe Write 2 OK" in res[0].log and
                      "Pipe Read 2: Hello World 2" in res[0].log)

rv = regression.run_checks()
if rv: sys.exit(rv)

import os, sys, mmap
from regression import Regression

loader = os.environ['PAL_LOADER']

regression = Regression(loader, "Symbols")

all_symbols = [
    'DkVirtualMemoryAlloc',
    'DkVirtualMemoryFree',
    'DkVirtualMemoryProtect',
    'DkProcessCreate',
    'DkProcessExit',
    'DkProcessSandboxCreate',
    'DkStreamOpen',
    'DkStreamWaitForClient',
    'DkStreamRead',
    'DkStreamWrite',
    'DkStreamDelete',
    'DkStreamMap',
    'DkStreamUnmap',
    'DkStreamSetLength',
    'DkStreamFlush',
    'DkSendHandle',
    'DkReceiveHandle',
    'DkStreamAttributesQuery',
    'DkStreamAttributesQueryByHandle',
    'DkStreamAttributesSetByHandle',
    'DkStreamGetName',
    'DkStreamChangeName',
    'DkThreadCreate',

import os, sys, mmap
from regression import Regression

loader = sys.argv[1]

# Running Bootstrap
regression = Regression(loader, "bootstrap")

regression.add_check(name="Basic Bootstrapping",
    check=lambda res: "User Program Started" in res[0].out)

regression.add_check(name="One Argument Given",
    check=lambda res: "# of Arguments: 1" in res[0].out and \
            "argv[0] = file:bootstrap" in res[0].out)

regression.add_check(name="Five Arguments Given",
    args = ['a', 'b', 'c', 'd'],
    check=lambda res: "# of Arguments: 5" in res[0].out and \
           "argv[0] = file:bootstrap" in res[0].out and \
           "argv[1] = a" in res[0].out and "argv[2] = b" in res[0].out and \
           "argv[3] = c" in res[0].out and "argv[4] = d" in res[0].out)

rv = regression.run_checks()
if rv: sys.exit(rv)

# Running Exec
regression = Regression(loader, "exec")

regression.add_check(name="2 page child binary",
    check=lambda res: "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 " in res[0].out)

import os, sys, mmap
from regression import Regression

loader = sys.argv[1]

# Running getsockopt
regression = Regression(loader, "getsockopt", None)

regression.add_check(name="getsockopt",
    check=lambda res: "getsockopt: Got socket type OK" in res[0].out)

rv = regression.run_checks()
if rv: sys.exit(rv)

#!/usr/bin/python

import os, sys, mmap
from regression import Regression

loader = '../src/pal'

regression = Regression(loader, "Thread")

regression.add_check(name="Thread Creation",
    check=lambda res: "Child Thread Created" in res[0].log and
                      "Run in Child Thread: Hello World" in res[0].log)

regression.add_check(name="Multiple Threads Run in Parallel",
    check=lambda res: "Threads Run in Parallel OK" in res[0].log)

regression.add_check(name="Set Thread Private Segment Register",
    check=lambda res: "Private Message (FS Segment) 1: Hello World 1" in res[0].log and
                      "Private Message (FS Segment) 2: Hello World 2" in res[0].log)

regression.add_check(name="Thread Exit",
    check=lambda res: "Child Thread Exited" in res[0].log)

regression.run_checks()

#!/usr/bin/python

import os, sys, mmap
from regression import Regression

loader = '../src/pal'

# Running Bootstrap
regression = Regression(loader, "Bootstrap")

regression.add_check(name="Basic Bootstrapping",
    check=lambda res: "User Program Started" in res[0].log)

regression.add_check(name="Control Block: Executable Name",
    check=lambda res: "Loaded Executable: file:Bootstrap" in res[0].log)

regression.add_check(name="Control Block: Default Manifest",
    check=lambda res: "Loaded Manifest: file:manifest" in res[0].log)

regression.add_check(name="One Argument Given",
    check=lambda res: "# of Arguments: 1" in res[0].log and \
            "argv[0] = file:Bootstrap" in res[0].log)

regression.add_check(name="Five Arguments Given",
    args = ['a', 'b', 'c', 'd'],
    check=lambda res: "# of Arguments: 5" in res[0].log and \
           "argv[0] = file:Bootstrap" in res[0].log and \
           "argv[1] = a" in res[0].log and "argv[2] = b" in res[0].log and \
           "argv[3] = c" in res[0].log and "argv[4] = d" in res[0].log)

regression.add_check(name="Control Block: Debug Stream (Inline)",

## This test is specifically for the reference monitor code, not process creation in general.
## It is not well-tested right now, but keep the tests around for future work.

import os, sys, mmap
from regression import Regression

loader = os.environ['PAL_SEC']

if not os.path.exists(loader):
    print("Reference monitor mode is not available on this platform")
    exit(0)

regression = Regression(loader, "Process")

def check_times(target, lines, times):
    count = 0
    for line in lines:
        if target == line:
            count += 1
    return count == times

regression.add_check(name="Process Creation",
    check=lambda res: check_times("Child Process Created", res[0].log, 3))

regression.add_check(name="Process Creation Arguments",
    check=lambda res: check_times("argv[0] = Process", res[0].log, 3) and
                      check_times("argv[1] = Child",   res[0].log, 3))

regression.add_check(name="Process Channel Transmission",
    check=lambda res: check_times("Process Write 1 OK",            res[0].log, 3) and
                      check_times("Process Read 1: Hello World 1", res[0].log, 3) and

import os, sys
from regression import Regression

loader = sys.argv[1]

# Running Bootstrap
regression = Regression(loader, "proc-path")

regression.add_check(name="Base /proc path present",
    check=lambda res: "proc path test success" in res[0].out)

rv = regression.run_checks()
if rv: sys.exit(rv)

#!/usr/bin/python

import os, sys, mmap
from regression import Regression

loader = '../src/pal'

regression = Regression(loader, "Misc", timeout=5000)

regression.add_check(name="Query System Time",
    check=lambda res: "Query System Time OK" in res[0].log)

regression.add_check(name="Delay Execution for 10000 Microseconds",
    check=lambda res: "Delay Execution for 10000 Microseconds OK" in res[0].log)

regression.add_check(name="Delay Execution for 3 Seconds",
    check=lambda res: "Delay Execution for 3 Seconds OK" in res[0].log)

regression.add_check(name="Generate Random Bits",
    check=lambda res: "Generate Random Bits OK" in res[0].log)

regression.run_checks()

import os, sys, mmap
from regression import Regression

loader = os.environ['PAL_LOADER']

regression = Regression(loader, "SendHandle")

def check_times(target, lines, times):
    count = 0
    for line in lines:
        if target == line:
            count += 1
    return count == times

regression.add_check(name="Send and Receive Handles across Processes",
    check=lambda res: check_times("Send Handle OK", res[0].log, 3) and
                      check_times("Receive Handle OK", res[0].log, 3))

regression.add_check(name="Send Pipe Handle",
        check=lambda res: check_times("Receive Pipe Handle: Hello World", res[0].log, 1))

regression.add_check(name="Send Socket Handle",
        check=lambda res: check_times("Receive Socket Handle: Hello World", res[0].log, 1))

regression.add_check(name="Send File Handle",
        check=lambda res: check_times("Receive File Handle: Hello World", res[0].log, 1))

rv = regression.run_checks()
if rv: sys.exit(rv)

import os, sys, mmap
from regression import Regression

loader = os.environ['PAL_LOADER']

regression = Regression(loader, "Socket")

regression.add_check(name="TCP Socket Creation",
    check=lambda res: "TCP Creation 1 OK" in res[0].log)

regression.add_check(name="TCP Socket Connection",
    check=lambda res: "TCP Connection 1 OK" in res[0].log)

regression.add_check(name="TCP Socket Transmission",
    check=lambda res: "TCP Write 1 OK" in res[0].log and
                      "TCP Read 1: Hello World 1" in res[0].log and
                      "TCP Write 2 OK" in res[0].log and
                      "TCP Read 2: Hello World 2" in res[0].log)

regression.add_check(name="UDP Socket Creation",
    check=lambda res: "UDP Creation 1 OK" in res[0].log)

regression.add_check(name="UDP Socket Connection",
    check=lambda res: "UDP Connection 1 OK" in res[0].log)

regression.add_check(name="UDP Socket Transmission",
    check=lambda res: "UDP Write 1 OK" in res[0].log and
                      "UDP Read 1: Hello World 1" in res[0].log and
                      "UDP Write 2 OK" in res[0].log and
                      "UDP Read 2: Hello World 2" in res[0].log)

#!/usr/bin/python

import os, sys, mmap
from regression import Regression

loader = '../src/pal'

regression = Regression(loader, "Exception")

def check_exception1(res):
    for line in res[0].log:
        if not line:
            continue
        if line.startswith('Div-by-Zero Exception Handler'):
            return True
    return False

regression.add_check(name="Exception Handling (Div-by-Zero)", check=check_exception1)

def check_exception2(res):
    for line in res[0].log:
        if not line:
            continue
        if line.startswith('Memory Fault Exception Handler'):
            return True
    return False

regression.add_check(name="Exception Handling (Memory Fault)", check=check_exception2)

def check_exception3(res):
    found1 = False

def prepare_files(args):
    global file_exist
    file_exist = ''.join([random.choice(string.ascii_letters) for i in range(mmap.PAGESIZE)])

    with open("file_exist.tmp", "w") as f:
        f.write(file_exist)

    if os.path.exists("file_nonexist.tmp"):
        os.remove("file_nonexist.tmp")

    with open("file_delete.tmp", "w") as f:
        f.write(file_exist)

# Running File
regression = Regression(loader, "File", prepare_files)

regression.add_check(name="Basic File Opening",
    check=lambda res: "File Open Test 1 OK" in res[0].log and
                      "File Open Test 2 OK" in res[0].log and
                      "File Open Test 3 OK" in res[0].log)

regression.add_check(name="Basic File Creation",
    check=lambda res: "File Creation Test 1 OK" in res[0].log and
                      "File Creation Test 2 OK" in res[0].log and
                      "File Creation Test 3 OK" in res[0].log)

regression.add_check(name="File Reading",
    check=lambda res: ("Read Test 1 (0th - 40th): " + file_exist[0:40]) in res[0].log and
                      ("Read Test 2 (0th - 40th): " + file_exist[0:40]) in res[0].log and
                      ("Read Test 3 (200th - 240th): " + file_exist[200:240]) in res[0].log)