Beispiel #1
0
func TestPutTwice(t *testing.T) {
	path := fixture.MakeFile()
	defer os.Remove(path)

	file, err := Create(path)
	assert.Success(err, t)
	defer file.Close()

	assert.Success(file.Put("A", 42), t)
	assert.Success(file.Put("A", 42), t)
}
func TestParseNaturalIndex(t *testing.T) {
	cases := []struct {
		line   string
		min    uint
		max    uint
		result []uint
	}{
		{"", 0, 10, nil},
		{"[]", 0, 10, []uint{}},
		{"[0, 1, 11]", 0, 10, nil},
		{"[0, 1, 9, 10]", 0, 10, []uint{0, 1, 9, 10}},
		{"[0:10]", 0, 10, []uint{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}},
		{"[1:2:10]", 0, 10, []uint{1, 3, 5, 7, 9}},
		{"[0:2:10]", 0, 10, []uint{0, 2, 4, 6, 8, 10}},
		{"[0:5:15]", 0, 10, nil},
		{"[0, 1, end]", 0, 10, []uint{0, 1, 10}},
		{"[0:2:end]", 0, 10, []uint{0, 2, 4, 6, 8, 10}},
		{"[0:end]", 0, 10, []uint{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}},
	}

	for _, c := range cases {
		result, err := ParseNaturalIndex(c.line, c.min, c.max)
		if c.result != nil {
			assert.Success(err, t)
		}
		assert.Equal(result, c.result, t)
	}
}
func TestParseRealIndex(t *testing.T) {
	cases := []struct {
		line   string
		min    float64
		max    float64
		result []float64
	}{
		{"", 0, 1, nil},
		{"[]", 0, 1, []float64{}},
		{"[0, 0.1, 0.9, 1]", 0, 1, []float64{0.0, 0.1, 0.9, 1.0}},
		{"[0, 0.1, 1.1]", 0, 1, nil},
		{"[0:1]", 0, 1, []float64{0, 1}},
		{"[0.1:0.2:1]", 0, 1, []float64{0.1, 0.3, 0.5, 0.7, 0.9}},
		{"[0:0.2:1]", 0, 1, []float64{0.0, 0.2, 0.4, 0.6, 0.8, 1.0}},
		{"[0:0.5:1.5]", 0, 1, nil},
		{"[0, 0.2, end]", 0, 1, []float64{0.0, 0.2, 1.0}},
		{"[0:0.2:end]", 0, 1, []float64{0.0, 0.2, 0.4, 0.6, 0.8, 1.0}},
		{"[0:end]", 0, 1, []float64{0, 1}},
	}

	for _, c := range cases {
		result, err := ParseRealIndex(c.line, c.min, c.max)
		if c.result != nil {
			assert.Success(err, t)
		}
		assert.EqualWithin(result, c.result, 1e-15, t)
	}
}
func TestParse(t *testing.T) {
	cases := []struct {
		line    string
		success bool
	}{
		{"Beta(1, 1)", true},
		{"beta(0.5, 1.5)", true},
		{" Beta \t (1, 1)", true},
		{"Gamma(1, 1)", false},
		{"Beta(1, 1, 1)", false},
		{"beta(-1, 1)", false},
		{"beta(0, 1)", false},
		{"beta(1, -1)", false},
		{"beta(1, 0)", false},
		{"beta(1, 0)", false},
		{"uniform()", true},
		{"uniform( )", true},
	}

	for _, c := range cases {
		if _, err := Parse(c.line); c.success {
			assert.Success(err, t)
		} else {
			assert.Failure(err, t)
		}
	}
}
Beispiel #5
0
func TestExtractTaskNumber(t *testing.T) {
	scenarios := []struct {
		name    string
		total   uint
		result  uint
		success bool
	}{
		{"t0_0", 50, 0, true},
		{"t0_42", 50, 42, true},
		{"t0_42", 43, 42, true},
		{"t0_42", 42, 0, false},
		{"t1_42", 50, 0, false},
		{"t0_-2", 50, 0, false},
	}

	for _, s := range scenarios {
		result, err := extractTaskID(s.name, s.total)

		if s.success {
			assert.Success(err, t)
		} else {
			assert.Failure(err, t)
		}

		assert.Equal(result, s.result, t)
	}
}
func TestCorrelateLarge(t *testing.T) {
	_, application, _ := system.Load("fixtures/016_160.tgff")

	ε := math.Sqrt(math.Nextafter(1.0, 2.0) - 1.0)
	R := Compute(application, index(160), 5)
	_, _, err := decomposition.CovPCA(R, 160, ε)
	assert.Success(err, t)
}
func TestCorrelateSmall(t *testing.T) {
	_, application, _ := system.Load("fixtures/002_020.tgff")

	R := Compute(application, index(20), 2)
	_, _, err := decomposition.CovPCA(R, 20, 0)
	assert.Success(err, t)

	R = Compute(application, index(1), 2)
	assert.Equal(R, []float64{1.0}, t)
}
Beispiel #8
0
func TestPut(t *testing.T) {
	path := fixture.MakeFile()
	defer os.Remove(path)

	file, _ := Open(path, "w7.3")
	defer file.Close()

	for i, o := range fixtureObjects {
		assert.Success(file.Put(fmt.Sprintf("%c", 'A'+i), o), t)
	}
}
Beispiel #9
0
func TestPutMatrix(t *testing.T) {
	path := fixture.MakeFile()
	defer os.Remove(path)

	file, _ := Open(path, "w7.3")
	defer file.Close()

	name, rows, cols := "a", uint(2), uint(3)
	data := []float64{1, 2, 3, 4, 5, 6}

	assert.Success(file.PutMatrix(name, data, rows, cols), t)
}
Beispiel #10
0
func TestGet(t *testing.T) {
	path := findFixture("data.mat")

	file, _ := Open(path, "r")
	defer file.Close()

	for i, o := range fixtureObjects {
		v := reflect.New(reflect.TypeOf(o))
		p := v.Interface()
		assert.Success(file.Get(fmt.Sprintf("%c", 'A'+i), p), t)
		assert.Equal(reflect.Indirect(v).Interface(), o, t)
	}
}
Beispiel #11
0
func TestPutGet(t *testing.T) {
	path := fixture.MakeFile()
	defer os.Remove(path)

	file, err := Create(path)
	assert.Success(err, t)
	for i, o := range fixtureObjects {
		assert.Success(file.Put(fmt.Sprintf("%c", 'A'+i), o), t)
	}
	assert.Success(file.Close(), t)

	file, err = Open(path)
	assert.Success(err, t)
	for i, o := range fixtureObjects {
		v := reflect.New(reflect.TypeOf(o))
		p := v.Interface()
		assert.Success(file.Get(fmt.Sprintf("%c", 'A'+i), p), t)
		assert.Equal(reflect.Indirect(v).Interface(), o, t)
	}
	assert.Success(file.Close(), t)
}
Beispiel #12
0
func TestPutGetWithDimensions(t *testing.T) {
	path := fixture.MakeFile()
	defer os.Remove(path)

	data1 := []float64{
		0.01, 0.02,
		0.03, 0.04,
		0.05, 0.06,

		0.07, 0.08,
		0.09, 0.10,
		0.11, 0.12,

		0.13, 0.14,
		0.15, 0.16,
		0.17, 0.18,

		0.19, 0.20,
		0.21, 0.22,
		0.23, 0.24,
	}

	file, err := Create(path)
	assert.Success(err, t)
	assert.Success(file.Put("data", data1, 2, 3, 4), t)
	assert.Success(file.Close(), t)

	data2 := []float64{}

	file, err = Open(path)
	assert.Success(err, t)
	assert.Success(file.Get("data", &data2), t)
	assert.Success(file.Close(), t)

	assert.Equal(data1, data2, t)
}
Beispiel #13
0
func TestCovPCA(t *testing.T) {
	Σ := []float64{
		+1.000000000000000e+00,
		+1.154127058177033e-01,
		+3.134709671301593e-01,
		-2.624605475789556e-01,
		-2.675628902376415e-01,
		+1.154127058177033e-01,
		+1.000000000000000e+00,
		+1.487775664601468e-01,
		+8.251722261621278e-01,
		+6.471493243665016e-01,
		+3.134709671301593e-01,
		+1.487775664601468e-01,
		+1.000000000000000e+00,
		+2.188948568766876e-01,
		-4.746506616202846e-01,
		-2.624605475789556e-01,
		+8.251722261621278e-01,
		+2.188948568766876e-01,
		+1.000000000000000e+00,
		+7.047860759340304e-01,
		-2.675628902376415e-01,
		+6.471493243665017e-01,
		-4.746506616202846e-01,
		+7.047860759340304e-01,
		+1.000000000000000e+00,
	}

	expectedU := []float64{
		-1.777008675251867e-01,
		+5.456098595844089e-01,
		-7.679302728419535e-02,
		+5.862167305996994e-01,
		+5.667319106337718e-01,
		+5.274851240801810e-01,
		+3.209998200695767e-01,
		+7.174077977724287e-01,
		+1.998699259327777e-01,
		-2.531731103264220e-01,
		+7.655128668903998e-01,
		+1.936393917712877e-01,
		-4.774829578033630e-01,
		-2.733383132570983e-01,
		+2.716431999752671e-01,
		-2.541030814371850e-01,
		+7.277625876615521e-01,
		-2.402296315689612e-01,
		-2.880993167658167e-01,
		-5.148609014089138e-01,
		+1.990063320205669e-01,
		-1.792607000828338e-01,
		-4.401461482047020e-01,
		+6.772642819885449e-01,
		-5.252109497950679e-01,
	}

	expectedΛ := []float64{
		2.500258665819985e+00,
		1.525542276483301e+00,
		8.324395052148045e-01,
		1.261010747114109e-01,
		1.565847777049709e-02,
	}

	U, Λ, err := CovPCA(Σ, 5, 0.0)

	assert.Success(err, t)
	assert.EqualWithin(Λ, expectedΛ, 1e-14, t)
	assert.EqualWithin(abs(U), abs(expectedU), 1e-14, t)
}
Beispiel #14
0
func TestLoadTGFF(t *testing.T) {
	platform, application, err := loadTGFF(findFixture("002_040"))

	assert.Success(err, t)
	assert.Equal(len(platform.Cores), 2, t)
	assert.Equal(len(application.Tasks), 40, t)

	tasks := []struct {
		children []uint
	}{
		{[]uint{1}},
		{[]uint{2, 3, 23, 32}},
		{[]uint{4, 10, 11, 12}},
		{[]uint{9, 10, 26}},
		{[]uint{5, 6, 7, 8}},

		{[]uint{10, 11, 27}},
		{nil},
		{[]uint{9}},
		{[]uint{9}},
		{[]uint{13, 14, 15}},

		{[]uint{12}},
		{[]uint{12, 31}},
		{[]uint{17, 18, 24}},
		{[]uint{16, 25}},
		{[]uint{36}},

		{[]uint{19, 20, 23, 29}},
		{[]uint{31}},
		{[]uint{22, 35}},
		{[]uint{21, 23}},
		{[]uint{20, 24}},

		{[]uint{24, 26}},
		{[]uint{27}},
		{[]uint{28, 29}},
		{[]uint{31}},
		{[]uint{30}},

		{[]uint{37, 38}},
		{nil},
		{[]uint{33, 34}},
		{[]uint{29}},
		{nil},

		{nil},
		{[]uint{36}},
		{nil},
		{nil},
		{nil},

		{nil},
		{nil},
		{nil},
		{[]uint{39}},
		{nil},
	}

	for i, task := range tasks {
		assert.Equal(application.Tasks[i].Children, task.children, t)
	}
}