abc-api/abcParser
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Fix the failing unit tests

Browse Source 
refactor the codestyle for the tests we wanted to keep
This commit is contained in:
richard
2017-10-17 06:41:19 -04:00
parent 8ae78ef047
commit 0cc8361929
40 changed files with 1395 additions and 5439 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
tests/unit/memory/AbcParserTest.php
View File

@@ -1,158 +1,100 @@
<?php
namespace Tests\Unit\Memory;
/**
* @group Lib
* @group Unit
*/
use App\Libraries\abcParse\AbcParser;
use XaiCorp\AbcParser\Models\Memory\Abc;
use XaiCorp\AbcParser\Models\Memory\Person;
use XaiCorp\AbcParser\Parser as AbcParser;
class AbcParserTest extends \Codeception\TestCase\Test
{
private $_facade;
private $valid_abc_1 = "
//blank first line means this isn't a file header anymore!
A: trad
B: Traditional English tunes
C: trad.
X:3
M:4/4
K:C
gaab babc :|
";
private $valid_abc_2 = "
X:40
T:Abbotts Bromley Horn Dance
A: trad
C: trad.
D: None
G:lute
H: Thousand year old tradition
The Horns live in the church and are removed for the dance once a year
R:Jig
F:none.abc
B: Traditional English tunes
W:None
Q:1/8=80
L:1/8
M:6/8
N:Traditional English
O:England
Z:Andy Hornby
%%TUNEURL: http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
%%ID:00000dab
S:http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
P:ABC
K:G
e|B2e G2e|B2e E2G|FGA GAB|1AGF G2:|2AGF E2|
|e|c2e cde|A2c ABc|FGA GFE|_E=EF B,2g|
e2g efg|c2e cde|dcB AGF|E3E2
|:A|BcB e3|BcB f3|BcB AGF|1G2F G2:|2E3-E2|]
";
private $valid_abc_3 = "A: trad
B: Traditional English tunes
C: trad.
D: None
F:none.abc
H: Thousand year old tradition
The Horns live in the church and are removed for the dance once a year
L:1/8
M:6/8
N:Traditional English
O:England
R:Jig
S:http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
Z:Andy Hornby
X:3
M:4/4
K:C
gaab babc :|
";
private $facade;
public function setUp()
{
parent::setup();
$this->_facade = new AbcParser();
$this->facade = new AbcParser(new Abc());
}
public function test_not_header_data_no_crash()
private function getValidAbc($filename = '/abc/valid_abc_1.abc')
{
$result = $this->_facade->parseABC($this->valid_abc_1);
$this->assertTrue(is_a($result, 'App\Libraries\abcParse\TuneCollection'));
return file_get_contents(codecept_data_dir($filename));
}
public function testNotHeaderDataNoCrash()
{
$result = $this->facade->parseABC($this->getValidAbc());
$this->assertInstanceOf(\XaiCorp\AbcParser\Models\Memory\TuneCollection::class, $result);
}
public function test_all_parameters_for_tune()
public function testAllParametersForTune()
{
$result = $this->_facade->parseABC($this->valid_abc_2);
$this->assertTrue(is_a($result, 'App\Libraries\abcParse\TuneCollection'));
$result = $this->facade->parseABC($this->getValidAbc('/abc/valid_abc_2.abc'));
// Tune details
// Tune details
$tune = $result[0];
// var_dump($tune); die();
$this->assertEquals('40', $result[0]->get('X'));
$this->assertEquals('Abbotts Bromley Horn Dance', array_shift($tune->get('T')) );
$this->assertEquals('England', array_shift($tune->get('O')) );
$this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'trad')), array_shift($tune->get('A')) );
$this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'trad.')), array_shift($tune->get('C')) );
$this->assertEquals('England', array_shift($tune->get('O')) );
$this->assertEquals('lute', array_shift($tune->get('G')) );
$this->assertEquals('Abbotts Bromley Horn Dance', current($tune->get('T')));
$this->assertEquals('England', current($tune->get('O')));
$this->assertEquals(new Person(['name' => 'trad']), current($tune->get('A')));
$this->assertEquals(new Person(['name' => 'trad.']), current($tune->get('C')));
$this->assertEquals('England', current($tune->get('O')));
$this->assertEquals('lute', current($tune->get('G')));
$history = $tune->get('H');
$this->assertEquals(2, count($history));
$this->assertEquals('Thousand year old tradition', $history[0] );
$this->assertEquals('The Horns live in the church and are removed for the dance once a year', $history[1] );
$this->assertEquals('Jig', array_shift($tune->get('R')) );
$this->assertEquals('Thousand year old tradition', $history[0]);
$this->assertEquals('The Horns live in the church and are removed for the dance once a year', $history[1]);
$this->assertEquals('Jig', current($tune->get('R')));
// setting details
$setting = $tune[0];
// var_dump($setting);die;
$this->assertEquals('Traditional English', array_shift($setting->get('N')) );
$this->assertEquals('1/8', $setting->get('L') );
$this->assertEquals('6/8', $setting->get('M') );
$this->assertEquals('G', $setting->get('K') );
$this->assertEquals('Traditional English', current($setting->get('N')));
$this->assertEquals('1/8', $setting->get('L'));
$this->assertEquals('6/8', $setting->get('M'));
$this->assertEquals('G', $setting->get('K'));
$expectedMusic = "
e|B2e G2e|B2e E2G|FGA GAB|1AGF G2:|2AGF E2|
|e|c2e cde|A2c ABc|FGA GFE|_E=EF B,2g|
e2g efg|c2e cde|dcB AGF|E3E2
|:A|BcB e3|BcB f3|BcB AGF|1G2F G2:|2E3-E2|]
";
$this->assertEquals(trim($expectedMusic), $setting->get('music'), "music strings should match" );
$this->assertEquals(trim($expectedMusic), $setting->get('music'), "music strings should match");
$Z = new App\Libraries\abcParse\Person(array('name'=>'Andy Hornby'));
$this->assertEquals($Z, array_shift($setting->get('Z')) );
$Z = new Person(['name' => 'Andy Hornby']);
$this->assertEquals($Z, current($setting->get('Z')));
$this->assertEquals('None', array_shift($setting->get('D')) );
$this->assertEquals('http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html', array_shift($setting->get('S')) );
$this->assertEquals('None', array_shift($setting->get('W')) );
$this->assertEquals('Traditional English tunes', array_shift($setting->get('B')) );
$this->assertEquals('none.abc', array_shift($setting->get('F')) );
$this->assertEquals('ABC', $setting->get('P') );
$this->assertEquals('1/8=80', $setting->get('Q') );
$this->assertEquals('None', current($setting->get('D')));
$this->assertEquals(
'http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html',
current($setting->get('S'))
);
$this->assertEquals('None', current($setting->get('W')));
$this->assertEquals('Traditional English tunes', current($setting->get('B')));
$this->assertEquals('none.abc', current($setting->get('F')));
$this->assertEquals('ABC', $setting->get('P'));
$this->assertEquals('1/8=80', $setting->get('Q'));
}
public function test_all_parameters_for_collection()
public function testAllParametersForCollection()
{
$collection = $this->_facade->parseABC($this->valid_abc_3);
$this->assertTrue(is_a($collection, 'App\Libraries\abcParse\TuneCollection'));
$collection = $this->facade->parseABC($this->getValidAbc('/abc/valid_abc_3.abc'));
$this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'trad')), array_shift($collection->get('A')) );
$this->assertEquals('Traditional English tunes', array_shift($collection->get('B')) );
$this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'trad.')), array_shift($collection->get('C')) );
$this->assertEquals('None', array_shift($collection->get('D')) );
$this->assertEquals('none.abc', array_shift($collection->get('F')) );
$this->assertEquals('Thousand year old tradition', array_shift($collection->get('H')) );
$this->assertEquals('1/8', $collection->get('L') );
$this->assertEquals('6/8', $collection->get('M') );
$this->assertEquals('Traditional English', array_shift($collection->get('N')) );
$this->assertEquals('England', array_shift($collection->get('O')) );
$this->assertEquals('Jig', $collection->get('R') );
$this->assertEquals('http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html', array_shift($collection->get('S')) );
$this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'Andy Hornby')), array_shift($collection->get('Z')) );
$this->assertEquals(new Person(['name' => 'trad']), current($collection->get('A')));
$this->assertEquals('Traditional English tunes', current($collection->get('B')));
$this->assertEquals(new Person(['name' => 'trad.']), current($collection->get('C')));
$this->assertEquals('None', current($collection->get('D')));
$this->assertEquals('none.abc', current($collection->get('F')));
$this->assertEquals('Thousand year old tradition', current($collection->get('H')));
$this->assertEquals('1/8', $collection->get('L'));
$this->assertEquals('6/8', $collection->get('M'));
$this->assertEquals('Traditional English', current($collection->get('N')));
$this->assertEquals('England', current($collection->get('O')));
$this->assertEquals('Jig', $collection->get('R'));
$this->assertEquals(
'http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html',
current($collection->get('S'))
);
$this->assertEquals(new Person(['name' => 'Andy Hornby']), current($collection->get('Z')));
}
}

104
tests/unit/memory/PabcTest.php
View File

@@ -1,104 +0,0 @@
<?php
/**
* @group Lib
* @group Unit
*/
use App\Libraries\abcParse\Pabc;
use App\Models\abcParse\Tune;
use App\Models\abcParse\TuneSetting as Setting;
use App\Models\abcParse\Person;
use App\Libraries\abcParse\TuneCollection;
class PabcTest extends \Codeception\TestCase\Test
{
private $_facade;
public function setUp()
{
$this->_facade = new Pabc();
}
private $valid_abc_1 = "
X:1
M:C
K:C
gaab babc :|
";
/**
* test the parse_abc function
*
* This method receives abc in a string
* and converts it into a Tune object.
* If the string is not valid abc no Tune object is created
* and the method returns false.
*
* @dataProvider provider_parse_abc
*/
public function test_parse_abc($string, $isValid)
{
$result = $this->_facade->parse_abc($string);
$this->assertEquals($isValid, is_a($result, TuneCollection::class));
}
public function provider_parse_abc()
{
return array(
array('not an abc', FALSE),
array($this->valid_abc_1, TRUE),
);
}
public function test_load_models()
{
$params = array(
'tuneModel' => new Tune(),
'settingModel' => new Setting(),
'personModel' => new Person(),
);
$this->_facade = new Pabc($params);
$this->assertInstanceOf(Tune::class, $this->_facade->tuneModel);
$this->assertInstanceOf(Setting::class, $this->_facade->settingModel);
$this->assertInstanceOf(Person::class, $this->_facade->personModel);
}
public function test_save_no_models()
{
$this->assertNull($this->_facade->tuneModel);
$result = $this->_facade->parse_abc($this->valid_abc_1);
$this->assertInstanceOf(TuneCollection::class, $result);
$this->assertFalse($result->get('change_hash'));
$saved = $this->_facade->save_collection($result);
$this->assertFalse($saved);
$this->assertFalse($result->get('change_hash'));
}
public function test_save()
{
$params = array(
'tuneModel' => Mockery::mock(Tune::Class, ['store'=>true]),
'settingModel' => Mockery::mock(Setting::class, ['store'=>true]),
'personModel' => Mockery::mock(Person::class, ['store'=>true]),
);
$this->_facade = new Pabc($params);
$result = $this->_facade->parse_abc($this->valid_abc_1);
$this->assertInstanceOf(TuneCollection::class, $result);
$this->assertFalse($result->get('change_hash'));
$saved = $this->_facade->save_collection($result);
$this->assertTrue($saved);
$this->assertNotNull($result->get('change_hash'));
}
}

155
tests/unit/memory/PersonTest.php
View File

@@ -1,40 +1,44 @@
<?php
/**
* @group Lib
* @group Unit
*/
namespace Tests\Unit\Memory;
use App\Libraries\abcParse\Person;
use \Codeception\TestCase\Test;
use Codeception\TestCase\Test;
use XaiCorp\AbcParser\Models\Memory\Person;
class PersonTest extends Test
{
private $_person;
private $person;
public function setUp()
{
$this->_person = new Person();
$this->person = new Person();
}
/**
* test the model contains the correct attributes
*/
public function test_model_definition()
public function testModelDefinition()
{
$this->assertClassHasAttribute('person_id', Person::class);
$this->assertClassHasAttribute('name', Person::class);
$this->assertClassHasAttribute('email', Person::class);
}
public function test_construct()
public function testConstruct()
{
$params = array('person_id' => 5);
$this->_person = new Person($params);
$params = ['person_id' => 5];
$this->person = new Person($params);
$this->assertEquals(5, $this->_person->get('person_id'));
$this->assertEquals(5, $this->person->get('person_id'));
}
/**
* @dataProvider providerSet
*/
public function testMagicSet($property, $value, $expected)
{
$this->testSet($property, $value, $expected);
}
/**
* test the set property method
@@ -43,74 +47,65 @@ class PersonTest extends Test
* @param (mixed) value to set
* @param (Boolean) expected value for return value of set method
*
* @dataProvider provider_set
* @dataProvider providerSet
*/
public function test_set($property, $value, $expected)
public function testSet($property, $value, $expected)
{
$success = $this->_person->set($property, $value);
$success = $this->person->set($property, $value);
$this->assertEquals($expected, $success);
if($success)
{
$this->assertEquals($value, $this->_person->get($property));
if ($success) {
$this->assertEquals($value, $this->person->get($property));
}
}
/**
* @dataProvider provider_set
*/
public function test_magic_set($property, $value, $expected)
public function providerSet()
{
$this->test_set($property, $value, $expected);
}
public function provider_set()
{
return array(
array('Y', 'anything', FALSE),
array('person_id', 'not', FALSE),
array('person_id', 11, TRUE),
array('person_id', '11', TRUE),
array('name', null, FALSE),
array('name', 1, FALSE),
array('name', 'anything', TRUE),
array('email', 'anything', FALSE),
array('email', 1, FALSE),
array('email', 'mail@example.com', TRUE),
);
return [
['Y', 'anything', false],
['person_id', 'not', false],
['person_id', 11, true],
['person_id', '11', true],
['name', null, false],
['name', 1, false],
['name', 'anything', true],
['email', 'anything', false],
['email', 1, false],
['email', 'mail@example.com', true],
];
}
/**
* @dataProvider provider_person_get
* @dataProvider providerPersonGet
*/
public function test_person_get($key, $expected)
public function testPersonGet($key, $expected)
{
$result = $this->_person->set($key, $expected);
$result = $this->_person->get($key);
$result = $this->person->set($key, $expected);
$result = $this->person->get($key);
$this->assertEquals($expected, $result);
}
public function provider_person_get()
public function providerPersonGet()
{
return array(
array('', FALSE),
array('me', FALSE),
array(array('of','me'), FALSE),
array(new Person(), FALSE),
array('name', 'Richard Morgan'),
array('email', 'r_morgan@sympatico.ca'),
array('person_id', 0)
);
return [
['', false],
['me', false],
[['of', 'me'], false],
[new Person(), false],
['name', 'Richard Morgan'],
['email', 'r_morgan@sympatico.ca'],
['person_id', 0],
];
}
public function test_is_changed()
public function testIsChanged()
{
$person = new Person(array('name'=>'Richard Morgan'));
$person = new Person(['name' => 'Richard Morgan']);
$this->assertInstanceOf(Person::class, $person);
$this->assertFalse($person->is_changed(), 'after load should be no changes');
$person->set('name','Richard Armitage');
$person->set('name', 'Richard Armitage');
$this->assertTrue($person->is_changed(), 'updating the name changes the data');
}
@@ -122,23 +117,18 @@ class PersonTest extends Test
* @param (array) $params list of properties to set on the objects
* @param (boolean) $expected result of running equals
*
* @dataProvider provider_equals
* @dataProvider providerEquals
*/
public function test_equals($params)
public function testEquals($params)
{
// $this->markTestIncomplete();
$ob1 = new Person();
$ob2 = new Person();
foreach($params as $key => $val)
{
if(is_array($ob1->get($key)))
{
foreach ($params as $key => $val) {
if (is_array($ob1->get($key))) {
$ob1->append($key, $val);
$ob2->append($key, $val);
}
else {
} else {
$ob1->set($key, $val);
$ob2->set($key, $val);
}
@@ -146,6 +136,7 @@ class PersonTest extends Test
$this->assertTrue(Person::equals($ob1, $ob2));
}
/**
* test the static function equals
* returns true if the data properties of 2 Person objects
@@ -154,36 +145,32 @@ class PersonTest extends Test
* @param (array) $params list of properties to set on the objects
* @param (boolean) $expected result of running equals
*
* @dataProvider provider_equals
* @dataProvider providerEquals
*/
public function test_equals_fails($params)
public function testEqualsFails($params)
{
$ob1 = new Person();
$ob2 = new Person();
foreach($params as $key => $val)
{
if(is_array($ob1->get($key)))
{
foreach ($params as $key => $val) {
if (is_array($ob1->get($key))) {
$ob1->append($key, $val);
$ob2->append($key, $val." hello");
}
else {
$ob2->append($key, $val . " hello");
} else {
$ob1->set($key, $val);
$ob2->set($key, $val+1);
$ob2->set($key, $val + 1);
}
}
// print_r($ob1); print_r($ob2); die;
$this->assertFalse(Person::equals($ob1, $ob2));
}
public function provider_equals()
public function providerEquals()
{
return array(
return [
// array( array('person_id'=>'2') ),
array( array('name'=>'a title') ),
array( array('email'=>'mail@example.com') ),
);
[['name' => 'a title']],
[['email' => 'mail@example.com']],
];
}
}

480
tests/unit/memory/SettingTest.php
View File

@@ -1,30 +1,30 @@
<?php
namespace Tests\Unit\Memory;
use App\Libraries\abcParse\Setting;
use App\Libraries\abcParse\Person;
use \Codeception\TestCase\Test as TestCase;
use Codeception\TestCase\Test as TestCase;
use XaiCorp\AbcParser\Models\Memory\Person;
use XaiCorp\AbcParser\Models\Memory\Setting;
/**
* @group Lib
*/
class SettingTest extends TestCase
{
private $_setting;
public function setUp()
{
$this->_setting = new Setting();
}
private $setting;
public function setUp()
{
$this->setting = new Setting();
}
/**
* test the model contains the correct attributes
*/
public function test_model_definition()
{
public function testModelDefinition()
{
$this->assertClassHasAttribute('settingID', Setting::class);
$this->assertClassHasAttribute('tuneID', Setting::class);
$this->assertClassHasAttribute('Z', Setting::class);
$this->assertClassHasAttribute('N', Setting::class);
$this->assertClassHasAttribute('D', Setting::class);
@@ -42,323 +42,313 @@ class SettingTest extends TestCase
// $this->assertClassHasAttribute('music_hash', Setting::class);
$this->assertClassHasAttribute('propertyNames', Setting::class);
}
}
/**
* test the set property method
*
*
* also tests the validate_line protected method
*
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to set
* @param (Boolean) expected value for return value of set method
*
* @dataProvider provider_set
*
* @dataProvider providerSet
*/
public function test_set($property, $value, $expected_success, $expected_value = FALSE)
public function testSet($property, $value, $expected_success, $expected_value = false)
{
$success = $this->_setting->set($property, $value);
$success = $this->setting->set($property, $value);
$this->assertEquals($expected_success, $success);
if($success)
{
if(! $expected_value ) { $expected_value = $value; }
$this->assertEquals($expected_value, $this->_setting->get($property));
if ($success) {
if (!$expected_value) {
$expected_value = $value;
}
$this->assertEquals($expected_value, $this->setting->get($property));
}
}
/**
* @dataProvider provider_set
*/
public function test_magic_set($property, $value, $expected_success, $expected_value = FALSE)
{
$this->_setting->$property = $value;
if($expected_success)
{
$this->assertEquals($value, $this->_setting->get($property));
}
}
public function provider_set()
{
return array(
array('Y', 'anything', FALSE),
array('settingID', 1, TRUE),
array('tuneID', array('alpha'), FALSE),
array('tuneID', 'alpha', FALSE),
array('tuneID', '1', TRUE),
array('tuneID', 1, TRUE),
array('f', 1, FALSE),
array('F', 1, FALSE),
array('F', '1',FALSE),
array('F', array('aplha'), TRUE),
array('P', array('string'), FALSE),
array('P', 10, FALSE),
array('P', 'string', TRUE),
array('Q', array('string'), FALSE),
array('Q', 10, FALSE),
array('Q', 'string', FALSE),
array('Q', '1/8=200', TRUE),
array('L', array('string'), FALSE),
array('L', 10, FALSE),
array('L', 'string', FALSE),
array('L', '1/8', TRUE),
array('M', array('string'), FALSE),
array('M', 10, FALSE),
array('M', 'string', FALSE),
array('M', '6/8', TRUE),
array('M', 'C', TRUE),
array('M', 'c', TRUE),
array('M', 'C|', TRUE),
array('K', array('string'), FALSE),
array('K', 10, FALSE),
array('K', 'C', TRUE),
array('K', 'Am', TRUE),
array('K', 'A minor', TRUE),
array('K', 'E dorian', TRUE),
array('music', 'GABc:|\\', TRUE),
array('Z', new Person(), FALSE),
array('Z', array(new Person(), 'not a person'), FALSE),
array('Z', array(new Person()), TRUE),
array('Z', 111, FALSE),
array('N', array('a string'), TRUE),
array('D', array('a string'), TRUE),
array('S', array('a string'), TRUE),
array('W', array('a string'), TRUE),
array('B', array('a string'), TRUE),
);
/**
* @dataProvider providerSet
*/
public function testMagicSet($property, $value, $expected_success, $expected_value = false)
{
$this->setting->$property = $value;
if ($expected_success) {
$this->assertEquals($value, $this->setting->get($property));
}
}
public function providerSet()
{
return [
['Y', 'anything', false],
['settingID', 1, true],
['tuneID', ['alpha'], false],
['tuneID', 'alpha', false],
['tuneID', '1', true],
['tuneID', 1, true],
['f', 1, false],
['F', 1, false],
['F', '1', false],
['F', ['aplha'], true],
['P', ['string'], false],
['P', 10, false],
['P', 'string', true],
['Q', ['string'], false],
['Q', 10, false],
['Q', 'string', false],
['Q', '1/8=200', true],
['L', ['string'], false],
['L', 10, false],
['L', 'string', false],
['L', '1/8', true],
['M', ['string'], false],
['M', 10, false],
['M', 'string', false],
['M', '6/8', true],
['M', 'C', true],
['M', 'c', true],
['M', 'C|', true],
['K', ['string'], false],
['K', 10, false],
['K', 'C', true],
['K', 'Am', true],
['K', 'A minor', true],
['K', 'E dorian', true],
['music', 'GABc:|\\', true],
['Z', new Person(), false],
['Z', [new Person(), 'not a person'], false],
['Z', [new Person()], true],
['Z', 111, false],
['N', ['a string'], true],
['D', ['a string'], true],
['S', ['a string'], true],
['W', ['a string'], true],
['B', ['a string'], true],
];
}
/**
* the settingID can only be set if it's value is currently 0
* this ensures that we can't change a setting's id once it's set.
* the default, unset value for settingID is 0
*/
public function test_set_settingID()
public function testSetSettingID()
{
$success = $this->_setting->set('settingID', 1);
$success = $this->setting->set('settingID', 1);
$this->assertTrue($success, 'first attempt should succeed');
$success = $this->_setting->set('settingID', 2);
$success = $this->setting->set('settingID', 2);
$this->assertFalse($success, 'second attempt should fail');
}
/**
* test the append value method
*
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to append
* @param (Boolean) expected value for return value of append method
*
* @dataProvider provider_append
*
* @dataProvider providerAppend
*/
public function test_append($property, $value, $expected)
public function testAppend($property, $value, $expected)
{
$success = $this->_setting->append($property, $value);
$success = $this->setting->append($property, $value);
$this->assertEquals($expected, $success);
if($success)
{
$this->assertContains($value, $this->_setting->get($property));
if ($success) {
$this->assertContains($value, $this->setting->get($property));
}
}
public function provider_append()
{
return array(
array('Y', 'anything', FALSE),
array('settingID', 1, FALSE),
array('tuneID', array('alpha'), FALSE),
array('tuneID', 'alpha', FALSE),
array('tuneID', '1', FALSE),
array('tuneID', 1, FALSE),
array('f', 1, FALSE),
array('F', 1, TRUE),
array('F', '1', TRUE),
array('F', array('aplha'), FALSE),
array('P', array('string'), FALSE),
array('P', 10, FALSE),
array('P', 'string', FALSE),
array('Q', array('string'), FALSE),
array('Q', 10, FALSE),
array('Q', 'string', FALSE),
array('Q', '1/8=200', FALSE),
array('L', array('string'), FALSE),
array('L', 10, FALSE),
array('L', 'string', FALSE),
array('L', '1/8', FALSE),
array('M', array('string'), FALSE),
array('M', 10, FALSE),
array('M', 'string', FALSE),
array('M', '6/8', FALSE),
array('M', 'C', FALSE),
array('M', 'c', FALSE),
array('M', 'C|', FALSE),
array('K', array('string'), FALSE),
array('K', 10, FALSE),
array('K', 'C', FALSE),
array('K', 'Am', FALSE),
array('K', 'A minor', FALSE),
array('K', 'E dorian', FALSE),
array('music', 'GABc:|\\', FALSE),
array('Z', new Person(), TRUE),
array('Z', array(new Person()), FALSE),
array('Z', 111, FALSE),
array('N', array('a string'), FALSE),
array('D', array('a string'), FALSE),
array('S', array('a string'), FALSE),
array('W', array('a string'), FALSE),
array('B', array('a string'), FALSE),
array('N', 'more notes', TRUE),
array('D', 'another record', TRUE),
array('S', 'another source', TRUE),
array('W', 'words', TRUE),
array('B', 'another book', TRUE),
);
}
/**
* @dataProvider provider_get
*/
public function test_get($key, $expected)
public function providerAppend()
{
$result = $this->_setting->set($key, $expected);
$result = $this->_setting->get($key);
return [
['Y', 'anything', false],
['settingID', 1, false],
['tuneID', ['alpha'], false],
['tuneID', 'alpha', false],
['tuneID', '1', false],
['tuneID', 1, false],
['f', 1, false],
['F', 1, true],
['F', '1', true],
['F', ['aplha'], false],
['P', ['string'], false],
['P', 10, false],
['P', 'string', false],
['Q', ['string'], false],
['Q', 10, false],
['Q', 'string', false],
['Q', '1/8=200', false],
['L', ['string'], false],
['L', 10, false],
['L', 'string', false],
['L', '1/8', false],
['M', ['string'], false],
['M', 10, false],
['M', 'string', false],
['M', '6/8', false],
['M', 'C', false],
['M', 'c', false],
['M', 'C|', false],
['K', ['string'], false],
['K', 10, false],
['K', 'C', false],
['K', 'Am', false],
['K', 'A minor', false],
['K', 'E dorian', false],
['music', 'GABc:|\\', false],
['Z', new Person(), true],
['Z', [new Person()], false],
['Z', 111, false],
['N', ['a string'], false],
['D', ['a string'], false],
['S', ['a string'], false],
['W', ['a string'], false],
['B', ['a string'], false],
['N', 'more notes', true],
['D', 'another record', true],
['S', 'another source', true],
['W', 'words', true],
['B', 'another book', true],
];
}
/**
* @dataProvider providerGet
*/
public function testGet($key, $expected)
{
$result = $this->setting->set($key, $expected);
$result = $this->setting->get($key);
$this->assertEquals($expected, $result);
}
public function provider_get()
public function providerGet()
{
return array(
array('', FALSE),
array('me', FALSE),
array('settingID', 1),
array('tuneID', 2),
array('Q', '1/8=100'),
array('L', '1/8'),
array('M', '6/8'),
array('K', 'Am'),
array('music', 'GABc:|\\'),
return [
['', false],
['me', false],
['settingID', 1],
['tuneID', 2],
['Q', '1/8=100'],
['L', '1/8'],
['M', '6/8'],
['K', 'Am'],
['music', 'GABc:|\\'],
['Z', [new Person()]],
['N', ['a string']],
['D', ['a string']],
['S', ['a string']],
['W', ['a string']],
['B', ['a string']],
];
}
array('Z', array(new Person())),
array('N', array('a string')),
array('D', array('a string')),
array('S', array('a string')),
array('W', array('a string')),
array('B', array('a string')),
);
}
/**
* test the static function equals
* returns true if the data properties of 2 Setting Objects
* are identical
*
*
* @param (array) $params list of properties to set on the objects
* @param (boolean) $expected result of running equals
*
* @dataProvider provider_equals
*
* @dataProvider providerEquals
*/
public function test_equals($params)
public function testEquals($params)
{
// $this->markTestIncomplete();
$ob1 = new Setting();
$ob2 = new Setting();
foreach($params as $key => $val)
{
if(is_array($ob1->get($key)))
{
foreach ($params as $key => $val) {
if (is_array($ob1->get($key))) {
$ob1->append($key, $val);
$ob2->append($key, $val);
}
else {
} else {
$ob1->set($key, $val);
$ob2->set($key, $val);
}
}
$this->assertTrue(Setting::equals($ob1, $ob2));
}
/**
* test the static function equals
* returns true if the data properties of 2 Abc_Tunes
* are identical
*
*
* @param (array) $params list of properties to set on the objects
* @param (boolean) $expected result of running equals
*
* @dataProvider provider_equals
*
* @dataProvider providerEquals
*/
public function test_equals_fails($params)
public function testEqualsFails($params)
{
$ob1 = new Setting();
$ob2 = new Setting();
foreach($params as $key => $val)
{
if(is_array($ob1->get($key)))
{
foreach ($params as $key => $val) {
if (is_array($ob1->get($key))) {
$ob1->append($key, $val);
// $ob2->append($key, $val);
}
else {
} else {
$ob1->set($key, $val);
$ob2->set($key, $val+1);
$ob2->set($key, $val + 1);
}
}
$this->assertFalse(Setting::equals($ob1, $ob2));
}
public function provider_equals()
public function providerEquals()
{
return array(
array( array('settingID'=>'2') ),
array( array('tuneID'=>'2') ),
array( array('Z'=> new Person()) ),
array( array('N'=>'an author') ),
array( array('D'=>'a composer') ),
array( array('S'=>'a group') ),
array( array('W'=>'some history') ),
array( array('B'=>'Plymouth') ),
array( array('F'=>'Jig') ),
array( array('P'=>'ABB') ),
array( array('Q'=>'1/8=100') ),
array( array('L'=>'1/4') ),
array( array('M'=>'2/4') ),
array( array('K'=>'G') ),
array( array('music'=>'a|cab|') ),
);
return [
[['settingID' => '2']],
[['tuneID' => '2']],
[['Z' => new Person()]],
[['N' => 'an author']],
[['D' => 'a composer']],
[['S' => 'a group']],
[['W' => 'some history']],
[['B' => 'Plymouth']],
[['F' => 'Jig']],
[['P' => 'ABB']],
[['Q' => '1/8=100']],
[['L' => '1/4']],
[['M' => '2/4']],
[['K' => 'G']],
[['music' => 'a|cab|']],
];
}
public function test_isChanged()
public function testIsChanged()
{
$setting = new Setting();
$this->assertInstanceOf(Setting::class, $setting);
$this->assertFalse($setting->is_changed(), 'after load should be no changes');
$setting->set('K','G');
$setting->set('K', 'G');
$this->assertTrue($setting->is_changed(), 'updating the name changes the data');
}
public function test_construct()
public function testConstruct()
{
$params = array(
$params = [
'settingID' => 3,
'Z' => array(new Person()),
'P' => 'ABC'
);
$this->_setting = new Setting ($params);
foreach($params as $key => $val)
{
$this->assertEquals($val, $this->_setting->get($key));
'Z' => [new Person()],
'P' => 'ABC',
];
$this->setting = new Setting($params);
foreach ($params as $key => $val) {
$this->assertEquals($val, $this->setting->get($key));
}
}
}

265
tests/unit/memory/TuneCollectionTest.php
View File

@@ -1,210 +1,203 @@
<?php
/**
* @group Lib
* @group Unit
*/
namespace Tests\Unit\Memory;
use XaiCorp\AbcParser\Models\Memory\Person;
use XaiCorp\AbcParser\Models\Memory\Tune;
use XaiCorp\AbcParser\Models\Memory\TuneCollection;
use Codeception\TestCase\Test as TestCase;
use App\Libraries\abcParse\Tune;
//use App\Libraries\memory\Setting;
use App\Libraries\abcParse\Person;
use App\Libraries\abcParse\TuneCollection;
use \Codeception\TestCase\Test as TestCase;
class TuneCollectionTest extends TestCase
{
private $_tunes;
private $tunes;
public function setUp()
{
$this->_tunes = new TuneCollection();
$this->tunes = new TuneCollection();
}
/**
* test the implementation of the Iterator interface
* 100% coverage! ;)
*/
public function test_iterator()
public function testIterator()
{
$t = new Tune();
$this->assertEquals(0, count($this->_tunes));
$this->_tunes[] = $t;
$this->_tunes->push($t);
$this->assertEquals(2, count($this->_tunes));
$this->assertInstanceOf(Tune::class, $this->_tunes[0], 'first tune');
$this->assertInstanceOf(Tune::class, $this->_tunes[1], 'second tune');
foreach($this->_tunes as $key=>$val)
{
$this->assertEquals(0, count($this->tunes));
$this->tunes[] = $t;
$this->tunes->push($t);
$this->assertEquals(2, count($this->tunes));
$this->assertInstanceOf(Tune::class, $this->tunes[0], 'first tune');
$this->assertInstanceOf(Tune::class, $this->tunes[1], 'second tune');
foreach ($this->tunes as $key => $val) {
$this->assertInternalType('scalar', $key);
$this->assertInstanceOf(Tune::class, $val);
$this->assertTrue(isset($this->_tunes[$key]), 'key is set');
unset($this->_tunes[$key]);
$this->assertFalse(isset($this->_tunes[$key]), 'key should have been unset');
$this->assertTrue(isset($this->tunes[$key]), 'key is set');
unset($this->tunes[$key]);
$this->assertFalse(isset($this->tunes[$key]), 'key should have been unset');
}
}
/**
* test the ability to remove the last tune from collection
*
*
* tests the implementation of the Countable interface
*/
public function test_pop()
public function testPop()
{
$this->assertEquals(0, count($this->_tunes), 'no tunes in collection to begin with');
$this->assertEquals(0, count($this->tunes), 'no tunes in collection to begin with');
$t = new Tune();
$this->_tunes->push($t);
$this->assertEquals(1, count($this->_tunes), '1 tune added to collection');
$result = $this->_tunes->pop();
$this->assertEquals(0, count($this->_tunes), 'no tunes left in collection');
$this->tunes->push($t);
$this->assertEquals(1, count($this->tunes), '1 tune added to collection');
$result = $this->tunes->pop();
$this->assertEquals(0, count($this->tunes), 'no tunes left in collection');
$this->assertInstanceOf(Tune::class, $result);
}
// public function test_construct()
// {
// $params = array(
// 'tc_id' => 5,
// 'cOwner' => 'me',
// 'B' => array('my tune book'),
// 'R' => 'reel'
// );
//
// $this->_tunes = new TuneCollection($params);
//
// foreach($params as $key => $val)
// {
// $this->assertEquals($val, $this->_tunes->get($key));
// }
// $params = array(
// 'tc_id' => 5,
// 'cOwner' => 'me',
// 'B' => array('my tune book'),
// 'R' => 'reel'
// );
//
// $this->_tunes = new TuneCollection($params);
//
// foreach($params as $key => $val)
// {
// $this->assertEquals($val, $this->_tunes->get($key));
// }
// }
/**
* test the set property method
*
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to set
* @param (Boolean) expected value for return value of set method
*
* @dataProvider provider_set
*
* @dataProvider providerSet
*/
public function test_set($property, $value, $expected)
public function testSet($property, $value, $expected)
{
$success = $this->_tunes->set($property, $value);
$success = $this->tunes->set($property, $value);
$this->assertEquals($expected, $success);
if($success)
{
$this->assertEquals($value, $this->_tunes->get($property));
if ($success) {
$this->assertEquals($value, $this->tunes->get($property));
}
}
/**
* test the set property method
*
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to set
* @param (Boolean) expected value for return value of set method
*
* @dataProvider provider_set
*
* @dataProvider providerSet
*/
public function test_magic_setter($property, $value, $expected)
public function testMagicSetter($property, $value, $expected)
{
$this->_tunes->$property = $value;
if($expected)
{
$this->assertEquals($value, $this->_tunes->get($property));
$this->tunes->$property = $value;
if ($expected) {
$this->assertEquals($value, $this->tunes->get($property));
}
}
public function provider_set()
public function providerSet()
{
return array(
array('Y', 'anything', FALSE),
array('A', 10, FALSE),
array('A', array('1','2'), FALSE),
array('A', array(new Person(),new Person()), TRUE),
array('C', 10, FALSE),
array('C', array('1','2'), FALSE),
array('C', array(new Person(),new Person()), TRUE),
array('H', 10, FALSE),
array('H', array('1','2'), TRUE),
array('O', 10, FALSE),
array('O', array('1','2'), TRUE),
array('R', 10, FALSE),
array('R', 'reel', TRUE),
array('collection', 10, FALSE),
array('collection', '10', FALSE),
array('collection', array(), FALSE),
array('collection', array('1','2'), FALSE),
array('collection', array(new Tune(), 'not a tune'), FALSE),
array('collection', array(new Tune()), TRUE),
array('tc_id', 'abc', FALSE),
array('tc_id', '11', TRUE),
array('tc_id', 15, TRUE),
array('cOwner', 'me', TRUE),
);
return [
['Y', 'anything', false],
['A', 10, false],
['A', ['1', '2'], false],
['A', [new Person(), new Person()], true],
['C', 10, false],
['C', ['1', '2'], false],
['C', [new Person(), new Person()], true],
['H', 10, false],
['H', ['1', '2'], true],
['O', 10, false],
['O', ['1', '2'], true],
['R', 10, false],
['R', 'reel', true],
['collection', 10, false],
['collection', '10', false],
['collection', [], false],
['collection', ['1', '2'], false],
['collection', [new Tune(), 'not a tune'], false],
['collection', [new Tune()], true],
['tc_id', 'abc', false],
['tc_id', '11', true],
['tc_id', 15, true],
['cOwner', 'me', true],
];
}
public function test_set_tc_id()
public function testSetTcId()
{
//we should start with tc_id = 0
$this->assertEquals(0, $this->_tunes->get('tc_id'), 'should start at 0');
$this->assertEquals(0, $this->tunes->get('tc_id'), 'should start at 0');
//because tc_id == 0 we can change value
$this->_tunes->set('tc_id', 4);
$this->assertEquals(4, $this->_tunes->get('tc_id'), 'should have changed to 4');
$this->tunes->set('tc_id', 4);
$this->assertEquals(4, $this->tunes->get('tc_id'), 'should have changed to 4');
//tc_id is not 0 so we cannot change value
$this->_tunes->set('tc_id', 11);
$this->assertEquals(4, $this->_tunes->get('tc_id'), 'should not have changed from 4');
$this->tunes->set('tc_id', 11);
$this->assertEquals(4, $this->tunes->get('tc_id'), 'should not have changed from 4');
}
/**
* test the append value method
*
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to append
* @param (Boolean) expected value for return value of append method
*
* @dataProvider provider_append
*
* @dataProvider providerAppend
*/
public function test_append($property, $value, $expected)
public function testAppend($property, $value, $expected)
{
$success = $this->_tunes->append($property, $value);
$success = $this->tunes->append($property, $value);
$this->assertEquals($expected, $success);
if($success)
{
$this->assertContains($value, $this->_tunes->get($property));
if ($success) {
$this->assertContains($value, $this->tunes->get($property));
}
}
public function provider_append()
public function providerAppend()
{
return array(
array('Y', 1, FALSE),
array('H', 'history', TRUE),
array('R', 'reel', TRUE),
array('r', 'reel', FALSE),
array('collection', 'setting', FALSE),
array('collection', new Tune(), TRUE),
array('collection', array(new Tune()), FALSE),
);
return [
['Y', 1, false],
['H', 'history', true],
['R', 'reel', true],
['r', 'reel', false],
['collection', 'setting', false],
['collection', new Tune(), true],
['collection', [new Tune()], false],
];
}
public function test_get()
public function testGet()
{
//R is a valid property so we should get it's value
$this->_tunes->set('R', 'reel');
$this->assertEquals('reel', $this->_tunes->get('R'));
$this->tunes->set('R', 'reel');
$this->assertEquals('reel', $this->tunes->get('R'));
//X is not a property, so we should get FALSE
$this->assertFalse($this->_tunes->get('X'));
$this->assertFalse($this->tunes->get('X'));
}
}

391
tests/unit/memory/TuneTest.php
View File

@@ -1,9 +1,11 @@
<?php
use App\Libraries\abcParse\Tune;
use App\Libraries\abcParse\Setting;
use App\Libraries\abcParse\Person;
use \Codeception\TestCase\Test as TestCase;
namespace Tests\Unit\Memory;
use XaiCorp\AbcParser\Models\Memory\Person;
use XaiCorp\AbcParser\Models\Memory\Setting;
use XaiCorp\AbcParser\Models\Memory\Tune;
use Codeception\TestCase\Test as TestCase;
/**
* @group Lib
@@ -11,17 +13,17 @@ use \Codeception\TestCase\Test as TestCase;
*/
class TuneTest extends TestCase
{
private $_tune;
public function setUp()
{
$this->_tune = new Tune();
}
private $tune;
public function setUp()
{
$this->tune = new Tune();
}
/**
* test the model contains the correct attributes
*/
public function test_model_definition()
public function testModelDefinition()
{
//Private attributes, probably shouldn't be tested
$this->assertClassHasAttribute('tuneID', Tune::class);
@@ -35,276 +37,265 @@ class TuneTest extends TestCase
$this->assertClassHasAttribute('X', Tune::class);
$this->assertClassHasAttribute('propertyNames', Tune::class);
}
/**
* test the set property method
*
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to set
* @param (Boolean) expected value for return value of set method
*
* @dataProvider provider_set
*
* @dataProvider providerSet
*/
public function test_set($property, $value, $expected)
public function testSet($property, $value, $expected)
{
$success = $this->_tune->set($property, $value);
$success = $this->tune->set($property, $value);
$this->assertEquals($expected, $success);
if($success)
{
$this->assertEquals($value, $this->_tune->get($property));
if ($success) {
$this->assertEquals($value, $this->tune->get($property));
}
}
/**
* test the set property method
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to set
* @param (Boolean) expected value for return value of set method
*
* @dataProvider provider_set
*/
public function test_magic_setter($property, $value, $expected)
{
$this->_tune->$property = $value;
// $this->assertEquals($expected, $success);
if($expected)
{
$this->assertEquals($value, $this->_tune->get($property));
}
}
/**
* @dataProvider provider_set
*/
public function test_construct($property, $value, $expected)
{
$params = array($property => $value);
$this->_tune = new Tune($params);
if($expected)
{
$this->assertEquals($value, $this->_tune->get($property));
}
}
public function provider_set()
{
return array(
array('Y', 'anything', FALSE),
array('x', 1, FALSE),
array('X', 1, TRUE),
array('X', 'aplha', FALSE),
array('X', '2', TRUE),
array('T', 'string', FALSE),
array('T', 10, FALSE),
array('T', array('1','2'), TRUE),
array('A', 10, FALSE),
array('A', array('1','2'), FALSE),
array('A', array(new Person(),new Person()), TRUE),
array('C', 10, FALSE),
array('C', array('1','2'), FALSE),
array('C', array(new Person(),new Person()), TRUE),
array('G', 10, FALSE),
array('G', array('1','2'), TRUE),
array('H', 10, FALSE),
array('H', array('1','2'), TRUE),
array('O', 10, FALSE),
array('O', array('1','2'), TRUE),
array('R', 10, FALSE),
array('R', array('1','2'), TRUE),
array('collection', 10, FALSE),
array('collection', '10', FALSE),
array('collection', array(), FALSE),
array('collection', array('1','2'), FALSE),
array('collection', array(new Setting()), TRUE),
array('tuneHash', 10, FALSE),
array('tuneHash', '10', FALSE),
array('tuneHash', array(), FALSE),
array('tuneHash', array('1','2'), FALSE),
array('tuneID', 'abc', FALSE),
array('tuneID', '11', TRUE),
array('tuneID', 15, TRUE),
);
}
public function test_set_tuneID()
/**
* test the set property method
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to set
* @param (Boolean) expected value for return value of set method
*
* @dataProvider providerSet
*/
public function testMagicSetter($property, $value, $expected)
{
$this->tune->$property = $value;
// $this->assertEquals($expected, $success);
if ($expected) {
$this->assertEquals($value, $this->tune->get($property));
}
}
/**
* @dataProvider providerSet
*/
public function testConstruct($property, $value, $expected)
{
$params = [$property => $value];
$this->tune = new Tune($params);
if ($expected) {
$this->assertEquals($value, $this->tune->get($property));
}
}
public function providerSet()
{
return [
['Y', 'anything', false],
['x', 1, false],
['X', 1, true],
['X', 'aplha', false],
['X', '2', true],
['T', 'string', false],
['T', 10, false],
['T', ['1', '2'], true],
['A', 10, false],
['A', ['1', '2'], false],
['A', [new Person(), new Person()], true],
['C', 10, false],
['C', ['1', '2'], false],
['C', [new Person(), new Person()], true],
['G', 10, false],
['G', ['1', '2'], true],
['H', 10, false],
['H', ['1', '2'], true],
['O', 10, false],
['O', ['1', '2'], true],
['R', 10, false],
['R', ['1', '2'], true],
['collection', 10, false],
['collection', '10', false],
['collection', [], false],
['collection', ['1', '2'], false],
['collection', [new Setting()], true],
['tuneHash', 10, false],
['tuneHash', '10', false],
['tuneHash', [], false],
['tuneHash', ['1', '2'], false],
['tuneID', 'abc', false],
['tuneID', '11', true],
['tuneID', 15, true],
];
}
public function testSetTuneID()
{
//we should start with tuneID = 0
$this->assertEquals(0, $this->_tune->get('tuneID'), 'should start at 0');
$this->assertEquals(0, $this->tune->get('tuneID'), 'should start at 0');
//because tuneID == 0 we can change value
$this->_tune->set('tuneID', 4);
$this->assertEquals(4, $this->_tune->get('tuneID'), 'should have changed to 4');
$this->tune->set('tuneID', 4);
$this->assertEquals(4, $this->tune->get('tuneID'), 'should have changed to 4');
//tuneID is not 0 so we cannot change value
$this->_tune->set('tuneID', 11);
$this->assertEquals(4, $this->_tune->get('tuneID'), 'should not have changed from 4');
$this->tune->set('tuneID', 11);
$this->assertEquals(4, $this->tune->get('tuneID'), 'should not have changed from 4');
}
/**
* test the append value method
*
*
* @param (string) $property, the name of the property to set
* @param (mixed) value to append
* @param (Boolean) expected value for return value of append method
*
* @dataProvider provider_append
*
* @dataProvider providerAppend
*/
public function test_append($property, $value, $expected)
public function testAppend($property, $value, $expected)
{
$success = $this->_tune->append($property, $value);
$success = $this->tune->append($property, $value);
$this->assertEquals($expected, $success);
if($success)
{
$this->assertContains($value, $this->_tune->get($property));
if ($success) {
$this->assertContains($value, $this->tune->get($property));
}
}
public function provider_append()
public function providerAppend()
{
return array(
array('Y', 1, FALSE),
array('X', 1, FALSE),
array('T','title', TRUE),
array('T', array('of','titles'), FALSE),
array('A', 'author', TRUE),
array('C', 'composer', TRUE),
array('G', 'Group', TRUE),
array('H', 'history', TRUE),
array('O', 'Origin', TRUE),
array('R', 'Rhythm', TRUE),
array('collection', 'setting', FALSE),
array('collection', new Setting(), TRUE),
array('collection', array(new Setting()), FALSE),
array('tuneHash', 'tuneHash', FALSE),
array('tuneHash', new Setting(), FALSE),
array('tuneHash', array(new Setting()), FALSE),
);
return [
['Y', 1, false],
['X', 1, false],
['T', 'title', true],
['T', ['of', 'titles'], false],
['A', 'author', true],
['C', 'composer', true],
['G', 'Group', true],
['H', 'history', true],
['O', 'Origin', true],
['R', 'Rhythm', true],
['collection', 'setting', false],
['collection', new Setting(), true],
['collection', [new Setting()], false],
['tuneHash', 'tuneHash', false],
['tuneHash', new Setting(), false],
['tuneHash', [new Setting()], false],
];
}
/**
* test the static function equals
* returns true if the data properties of 2 Abc_Tunes
* are identical
*
*
* @param (array) $params list of properties to set on the objects
* @param (boolean) $expected result of running equals
*
* @dataProvider provider_equals
*
* @dataProvider providerEquals
*/
public function test_equals($params)
public function testEquals($params)
{
// $this->markTestIncomplete();
$ob1 = new Tune();
$ob2 = new Tune();
foreach($params as $key => $val)
{
if(is_array($ob1->get($key)))
{
foreach ($params as $key => $val) {
if (is_array($ob1->get($key))) {
$ob1->append($key, $val);
$ob2->append($key, $val);
}
else {
} else {
$ob1->set($key, $val);
$ob2->set($key, $val);
}
}
$this->assertTrue(Tune::equals($ob1, $ob2));
}
/**
* test the static function equals
* returns true if the data properties of 2 Abc_Tunes
* are identical
*
*
* @param (array) $params list of properties to set on the objects
* @param (boolean) $expected result of running equals
*
* @dataProvider provider_equals
*
* @dataProvider providerEquals
*/
public function test_equals_fails($params)
public function testEqualsFails($params)
{
$ob1 = new Tune();
$ob2 = new Tune();
foreach($params as $key => $val)
{
if($key === 'collection')
{
foreach ($params as $key => $val) {
if ($key === 'collection') {
$ob1->set($key, $val);
}
else if(is_array($ob1->get($key)))
{
} elseif (is_array($ob1->get($key))) {
$ob1->append($key, $val);
}
else {
} else {
$ob1->set($key, $val);
}
}
$this->assertFalse(Tune::equals($ob1, $ob2));
}
public function provider_equals()
public function providerEquals()
{
$setting1 = new Setting(array('settingID'=>5, 'tuneID'=>444));
$setting2 = new Setting(array('settingID'=>3, 'tuneID'=>2244));
return array(
array( array('X'=>'2') ),
array( array('T'=>'a title') ),
array( array('A'=>'an author') ),
array( array('C'=>'a composer') ),
array( array('G'=>'a group') ),
array( array('H'=>'some history') ),
array( array('O'=>'Plymouth') ),
array( array('R'=>'Jig') ),
array( array('collection' => array($setting1, $setting2) ))
);
$setting1 = new Setting(['settingID' => 5, 'tuneID' => 444]);
$setting2 = new Setting(['settingID' => 3, 'tuneID' => 2244]);
return [
[['X' => '2']],
[['T' => 'a title']],
[['A' => 'an author']],
[['C' => 'a composer']],
[['G' => 'a group']],
[['H' => 'some history']],
[['O' => 'Plymouth']],
[['R' => 'Jig']],
[['collection' => [$setting1, $setting2]]],
];
}
public function test_isChanged()
public function testIsChanged()
{
$tune = new Tune();
$this->assertInstanceOf(Tune::class, $tune);
$this->assertFalse($tune->is_changed(), 'after load should be no changes');
$tune->set('X','5');
$tune->set('X', '5');
$this->assertTrue($tune->is_changed(), 'updating the name changes the data');
}
/**
* @dataProvider provider_get
* @dataProvider providerGet
*/
public function test_get($key, $expected)
public function testGet($key, $expected)
{
$result = $this->_tune->set($key, $expected);
$result = $this->_tune->get($key);
$result = $this->tune->set($key, $expected);
$result = $this->tune->get($key);
$this->assertEquals($expected, $result);
}
public function provider_get()
public function providerGet()
{
return array(
array('', FALSE),
array('me', FALSE),
array('tuneID', 2),
array('X', '2'),
array('T', array('1','2')),
array('A', array(new Person(),new Person())),
array('C', array(new Person(),new Person())),
array('G', array('1','2')),
array('H', array('1','2')),
array('O', array('1','2')),
array('R', array('1','2')),
array('collection', array(new Setting())),
);
return [
['', false],
['me', false],
['tuneID', 2],
['X', '2'],
['T', ['1', '2']],
['A', [new Person(), new Person()]],
['C', [new Person(), new Person()]],
['G', ['1', '2']],
['H', ['1', '2']],
['O', ['1', '2']],
['R', ['1', '2']],
['collection', [new Setting()]],
];
}
}