Midterm exam grades coming soon!!

Integration Testing

def test_some_method(parameter):
  '''
  '''

  # return true or false
def test_setup():
  '''
  '''

  # connect to database
  # or span server
def test_teardown():
  '''
  '''

  # delete temporary files
  # or close database connection

1. Setup

2. Test

3. Teardown

pytest

$ pytest
=========================== test session starts ============================
platform linux -- Python 3.x.y, pytest-5.x.y, py-1.x.y, pluggy-0.x.y
cachedir: $PYTHON_PREFIX/.pytest_cache
rootdir: $REGENDOC_TMPDIR
collected 1 item

test_sample.py F                                                     [100%]

================================= FAILURES =================================
_______________________________ test_answer ________________________________

    def test_answer():
>       assert inc(3) == 5
E       assert 4 == 5
E        +  where 4 = inc(3)

test_sample.py:6: AssertionError
========================= short test summary info ==========================
FAILED test_sample.py::test_answer - assert 4 == 5
============================ 1 failed in 0.12s =============================
# content of test_sample.py
def inc(x):
    return x + 1


def test_answer():
    assert inc(3) == 5
#include <cassert>

int main()
{
  assert(1==2);
  std::cout << "Will never be reached.";
}

Functions, Classes

Arrays, Vectors

Templates

GIBBS Cluster

Cython

Run our C++ code in Python using Cython

and compare timing against NumPy

Analyze a bunch of numbers and calculate min, max, mean, stddev.

Templates

Generic Programming

Type-Independent

"Blueprint"

Advanced!

Let's code!

int get_min(std::vector<int> v) {
    
    int minvalue = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        minvalue = std::min(minvalue, v[i]);
        
    }
    
    return minvalue;
}
void test_get_min() {

  std::vector<int> somevalues;

  somevalues.push_back(1);
  somevalues.push_back(2);
  somevalues.push_back(3);
  somevalues.push_back(-241);
  
  assert(get_min(somevalues)==-241);
  std::cout << "Test OK!" << std::endl;
    
}
float get_min_float(std::vector<float> v) {
    
    float minvalue = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        minvalue = std::min(minvalue, v[i]);
        
    }
    
    return minvalue;
}
void test_get_min_float() {

  std::vector<float> somevalues;

  somevalues.push_back(1.1);
  somevalues.push_back(2.31);
  somevalues.push_back(3.4);
  somevalues.push_back(-241.44);
  
  assert(get_min_float(somevalues)==-241.44);
  std::cout << "Test OK!" << std::endl;
    
}

get_min for integers

get_min for floats

void test_get_min_float() {

  std::vector<float> somevalues;

  somevalues.push_back(1.1);
  somevalues.push_back(2.31);
  somevalues.push_back(3.4);
  somevalues.push_back(-241.44);
  
  assert(get_min_float(somevalues)==-241.44);
  std::cout << "Test OK!" << std::endl;
    
}

Never got executed!

void test_get_min_float() {

  std::vector<float> somevalues;

  somevalues.push_back(1.1);
  somevalues.push_back(2.31);
  somevalues.push_back(3.4);
  somevalues.push_back(-241.44);
  
  float diff = std::abs( -241.44 ) - std::abs( get_min_float(somevalues) );
  
  assert(diff < 0.0005);
  std::cout << "Test OK!" << std::endl;
    
}

Check if we have a very small difference between two floats..

We can not just compare floats..

float onevalue = 0.33333333333333;

float secondvalue = 1/3;

if (onevalue == secondvalue) {

	// cancel life-support
	// ...
}

Developer is in charge of precision..

onevalue = 0.3333333333333333;

secondvalue = 1/3;

if (onevalue == secondvalue):
  print('equal')

int get_min(std::vector<int> v) {
    
    int minvalue = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        minvalue = std::min(minvalue, v[i]);
        
    }
    
    return minvalue;
}
void test_get_min() {

  std::vector<int> somevalues;

  somevalues.push_back(1);
  somevalues.push_back(2);
  somevalues.push_back(3);
  somevalues.push_back(-241);
  
  assert(get_min(somevalues)==-241);
  std::cout << "Test OK!" << std::endl;
    
}
float get_min_float(std::vector<float> v) {
    
    float minvalue = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        minvalue = std::min(minvalue, v[i]);
        
    }
    
    return minvalue;
}
void test_get_min_float() {

  std::vector<float> somevalues;

  somevalues.push_back(1.1);
  somevalues.push_back(2.31);
  somevalues.push_back(3.4);
  somevalues.push_back(-241.44);
  
  float diff = std::abs( -241.44 ) - std::abs( get_min_float(somevalues) );
  
  assert(diff < 0.0005);
  std::cout << "Test OK!" << std::endl;
    
}

get_min for integers

get_min for floats

template <typename T>

T get_min(std::vector<T> v) {
    
    T minvalue = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        minvalue = std::min(minvalue, v[i]);
        
    }
    
    return minvalue;
}
void test_get_min() {

  std::vector<int> somevalues;

  somevalues.push_back(1);
  somevalues.push_back(2);
  somevalues.push_back(3);
  somevalues.push_back(-241);
  
  assert(get_min(somevalues)==-241);
  std::cout << "Test OK!" << std::endl;
    
}
void test_get_min_float() {

  std::vector<float> somevalues;

  somevalues.push_back(1.1);
  somevalues.push_back(2.31);
  somevalues.push_back(3.4);
  somevalues.push_back(-241.44);
  
  float diff = std::abs( -241.44 ) - std::abs( get_min(somevalues) );
  
  assert(diff < 0.0005);
  std::cout << "Test OK!" << std::endl;
    
}

get_min for ints, floats...

int get_min(std::vector<int> v) {
    
    int minvalue = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        minvalue = std::min(minvalue, v[i]);
        
    }
    
    return minvalue;
}
template <typename T>
class Stats {
    
    public:
        static T get_min(std::vector<T> v);
        static T get_max(std::vector<T> v);
        static float get_mean(std::vector<T> v);
        
};

template <typename T>
T Stats<T>::get_min(std::vector<T> v) {
    
    T minvalue = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        minvalue = std::min(minvalue, v[i]);
        
    }
    
    return minvalue;
}

template <typename T>
T Stats<T>::get_max(std::vector<T> v) {
    
    T minvalue = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        minvalue = std::max(minvalue, v[i]);
        
    }
    
    return minvalue;
}
template <typename T>
float Stats<T>::get_mean(std::vector<T> v) {
    
    float sum = v[0];
    
    for(int i=1; i<v.size(); i++) {
        
        sum += v[i];
        
    }
    
    sum /= v.size();
    
    return sum;
}

Templated Classes!

More Friday....

CS410 Lecture 24

By Daniel Haehn

CS410 Lecture 24

Slides for CS410 Software Engineering at UMass Boston. See https://cs410.net!

  • 335