redmine::result redmine::config::load(redmine::options &options) { std::string path(config_path()); std::ifstream file(path); CHECK(!file.is_open(), fprintf(stderr, "could not open: %s\n", path.c_str()); return INVALID_CONFIG); std::string str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>()); auto Root = json::read(str); CHECK_JSON_TYPE(Root, json::TYPE_OBJECT); CHECK(options.debug, printf("%s\n", json::write(Root, " ").c_str())); // TODO: Properly handle missing config file with interactive creation. // TODO: Actually report config load error to stderr! auto Browser = Root.object().get("browser"); if (Browser) { CHECK_JSON_TYPE(*Browser, json::TYPE_STRING); browser = Browser->string(); } auto Editor = Root.object().get("editor"); if (Editor) { CHECK_JSON_TYPE(*Editor, json::TYPE_STRING); editor = Editor->string(); } auto ProfileName = Root.object().get("profile_name"); CHECK_JSON_PTR(ProfileName, json::TYPE_STRING); profile_name = ProfileName->string(); auto Profiles = Root.object().get("profiles"); CHECK_JSON_PTR(Profiles, json::TYPE_ARRAY); for (auto &Profile : Profiles->array()) { redmine::config::profile profile; auto Name = Profile.object().get("name"); CHECK_JSON_PTR(Name, json::TYPE_STRING); profile.name = Name->string(); auto Url = Profile.object().get("url"); CHECK_JSON_PTR(Url, json::TYPE_STRING); profile.url = Url->string(); auto Key = Profile.object().get("key"); CHECK_JSON_PTR(Key, json::TYPE_STRING); profile.key = Key->string(); auto Port = Profile.object().get("port"); CHECK_JSON_PTR(Port, json::TYPE_NUMBER); profile.port = Port->number<uint32_t>(); auto UseSsl = Profile.object().get("use_ssl"); if (UseSsl) { CHECK_JSON_TYPE(*UseSsl, json::TYPE_BOOL); profile.use_ssl = UseSsl->boolean(); } auto VerifySsl = Profile.object().get("verify_ssl"); if (VerifySsl) { CHECK_JSON_TYPE(*VerifySsl, json::TYPE_BOOL); profile.verify_ssl = VerifySsl->boolean(); } profiles.push_back(profile); } for (auto &profile : profiles) { if (profile.name == profile_name) { current = &profiles.back(); } } CHECK(!current, fprintf(stderr, "profile_name '%s' does not name a valid profile.\n", profile_name.c_str()); return FAILURE); return SUCCESS; }
array approx1(const array& yi, const array &xo, const interpType method, const float offGrid) { af_array yo = 0; AF_THROW(af_approx1(&yo, yi.get(), xo.get(), method, offGrid)); return array(yo); }
AFAPI array median(const array& in, const dim_t dim) { af_array temp = 0; AF_THROW(af_median(&temp, in.get(), getFNSD(dim, in.dims()))); return array(temp); }
array array::copy() const { return array(new array_impl(get_impl<array_impl>())); }
void QQuickCustomAffector::affectSystem(qreal dt) { //Acts a bit differently, just emits affected for everyone it might affect, when the only thing is connecting to affected(x,y) bool justAffected = (m_acceleration == &m_nullVector && m_velocity == &m_nullVector && m_position == &m_nullVector && isAffectedConnected()); if (!isAffectConnected() && !justAffected) { QQuickParticleAffector::affectSystem(dt); return; } if (!m_enabled) return; updateOffsets(); QList<QQuickParticleData*> toAffect; foreach (QQuickParticleGroupData* gd, m_system->groupData) if (activeGroup(m_system->groupData.key(gd))) foreach (QQuickParticleData* d, gd->data) if (shouldAffect(d)) toAffect << d; if (toAffect.isEmpty()) return; if (justAffected) { foreach (QQuickParticleData* d, toAffect) {//Not postAffect to avoid saying the particle changed if (m_onceOff) m_onceOffed << qMakePair(d->group, d->index); emit affected(d->curX(), d->curY()); } return; } if (m_onceOff) dt = 1.0; QQmlEngine *qmlEngine = ::qmlEngine(this); QV4::ExecutionEngine *v4 = QV8Engine::getV4(qmlEngine->handle()); QV4::Scope scope(v4); QV4::Scoped<QV4::ArrayObject> array(scope, v4->newArrayObject(toAffect.size())); QV4::ScopedValue v(scope); for (int i=0; i<toAffect.size(); i++) array->putIndexed(i, (v = toAffect[i]->v4Value())); if (dt >= simulationCutoff || dt <= simulationDelta) { affectProperties(toAffect, dt); emit affectParticles(QQmlV4Handle(array), dt); } else { int realTime = m_system->timeInt; m_system->timeInt -= dt * 1000.0; while (dt > simulationDelta) { m_system->timeInt += simulationDelta * 1000.0; dt -= simulationDelta; affectProperties(toAffect, simulationDelta); emit affectParticles(QQmlV4Handle(array), simulationDelta); } m_system->timeInt = realTime; if (dt > 0.0) { affectProperties(toAffect, dt); emit affectParticles(QQmlV4Handle(array), dt); } } foreach (QQuickParticleData* d, toAffect) if (d->update == 1.0) postAffect(d); }
int main () { int * arrrr = new int[14]; int * marrr; marrr = (int *) malloc (14); for (int i = 0; i < 14; i++) { arrrr[i] = i; marrr[i] = i + 1; } // SCOPED POINTER std::cout << "SCOPED_PTR: " << std::endl; scoped_ptr <int> arr (arrrr, arrdeleter <int> ()); scoped_ptr <int> array (marrr, mfree <int> ()); std::cout << arr.pointer() << ": Array created with 'new': "; for (int i = 0; i < 14; i++) std::cout << arr.pointer()[i] << " "; std::cout << "has an address " << &arr << std::endl; std::cout << array.pointer() << ": Array created with 'malloc': "; for (int i = 0; i < 14; i++) std::cout << array.pointer()[i] << " "; std::cout << "has an address " << &array << std::endl; std::cout << "Objects of class 'object' created with 'new' in loop of 3: " << std::endl; for (int i = 0; i < 3; i++) { object * t = new object (i); scoped_ptr <object> tre (t, objdeleter <object> ()); std::cout << "Pointer object address: " << &tre << " -> " << tre.pointer()->x << std::endl; } std::cout << std::endl; // AUTO POINTER std::cout << "AUTO_PTR: " << std::endl; auto_ptr <int> aarr(arrrr, arrdeleter <int> ()); auto_ptr <int> aarray(marrr, mfree <int> ()); std::cout << aarr.pointer() << ": Array created with 'new': "; for (int i = 0; i < 14; i++) std::cout << aarr.pointer()[i] << " "; std::cout << "has an address " << &aarr << std::endl; std::cout << aarray.pointer() << ": Array created with 'malloc': "; for (int i = 0; i < 14; i++) std::cout << aarray.pointer()[i] << " "; std::cout << "has an address " << &aarray << std::endl << std::endl; auto_ptr <int> copy = aarr; std::cout << copy.pointer() << ": Copy of pointer to first array: "; for (int i = 0; i < 14; i++) std::cout << copy.pointer()[i] << " "; std::cout << "has an address " << © << std::endl; std::cout << "Old pointer points to address " << aarr.pointer() << std::endl << std::endl; std::cout << "Objects of class 'object' created with 'new' in loop of 3: " << std::endl; for (int i = 0; i < 3; i++) { object * t = new object(i); auto_ptr <object> tre(t, objdeleter <object> ()); std::cout << "Pointer object address: " << &tre << " -> " << tre.pointer()->x << std::endl; } std::cout << std::endl; return 0; }
void LIRGenerator::do_StoreIndexed(StoreIndexed* x) { assert(x->is_root(),""); bool obj_store = x->elt_type() == T_ARRAY || x->elt_type() == T_OBJECT; LIRItem array(x->array(), this); LIRItem index(x->index(), this); LIRItem value(x->value(), this); if (obj_store) { array.set_destroys_register(); } value.handle_float_kind(); array.load_item(); index.load_nonconstant(); bool must_load = true; if (x->elt_type() == T_SHORT || x->elt_type() == T_CHAR) { // there is no immediate move of word values in asembler_i486.?pp must_load = true; } else { if (obj_store && value.is_constant() && !get_jobject_constant(x->value())->is_loaded()) { // do nothing; do not load (NULL object) must_load = false; } else if (value.is_constant() && !obj_store) { // array store check needs a register, otherwise do not load a constant must_load = false; } } if (must_load) { // for T_BYTE element type, we must have a byte register free if (x->elt_type() == T_BYTE || x->elt_type() == T_BOOLEAN) { value.load_byte_item(); } else { value.load_item(); } } set_no_result(x); CodeEmitInfo* range_check_info = state_for(x); CodeEmitInfo* null_check_info = NULL; bool needs_null_check = x->needs_null_check(); if (needs_null_check) { null_check_info = range_check_info; } if (GenerateRangeChecks) { emit()->array_range_check(array.result(), index.result(), null_check_info, range_check_info); // range_check also does the null check needs_null_check = false; } if (obj_store) { if (value.is_constant() && !get_jobject_constant(x->value())->is_loaded()) { // skip store check } else if (GenerateArrayStoreCheck) { RInfo tmp1 = new_register(objectType)->rinfo(); RInfo tmp2 = new_register(objectType)->rinfo(); RInfo tmp3 = new_register(objectType)->rinfo(); emit()->array_store_check(array.result(), value.result(), tmp1, tmp2, tmp3, range_check_info); } } emit()->indexed_store(x->elt_type(), array.result(), index.result(), value.result(), norinfo, null_check_info); }
ConstIterator rowBegin(size_t row) const { return ConstIterator(array() + row * numColumns(), 1); }
ConstIterator rowEnd(size_t row) const { return ConstIterator(array() + (row+1) * numColumns(), 1); }
array_t * print_form() { array_t *response; string_t *body; char *form_elements = " <div id=\"input_checkbox\">" " <label for=\"input_checkbox\">checkbox</label>" " <input type=\"checkbox\" name=\"input_checkbox\" id=\"input_checkbox\" />" " </div>" " <div id=\"input_color\">" " <label for=\"input_color\">color</label>" " <input type=\"color\" name=\"input_color\" id=\"input_color\" />" " </div>" " <div id=\"input_date\">" " <label for=\"input_date\">date</label>" " <input type=\"date\" name=\"input_date\" id=\"input_date\" />" " </div>" " <div id=\"input_datetime\">" " <label for=\"input_datetime\">datetime</label>" " <input type=\"datetime\" name=\"input_datetime\" id=\"input_datetime\" />" " </div>" " <div id=\"input_datetime-local\">" " <label for=\"input_datetime-local\">datetime-local</label>" " <input type=\"datetime-local\" name=\"input_datetime-local\" id=\"input_datetime-local\" />" " </div>" " <div id=\"input_email\">" " <label for=\"input_email\">email</label>" " <input type=\"email\" name=\"input_email\" id=\"input_email\" />" " </div>" " <div id=\"input_file\">" " <label for=\"input_file\">file</label>" " <input type=\"file\" name=\"input_file\" id=\"input_file\" />" " </div>" " <div id=\"input_file_multiple\">" " <label for=\"input_file_multiple\">file (multiple)</label>" " <input type=\"file\" name=\"input_file_multiple\" id=\"input_file_multiple\" multiple=\"multiple\"/>" " </div>" " <div id=\"input_hidden\">" " <label for=\"input_hidden\">hidden</label>" " <input type=\"hidden\" name=\"input_hidden\" id=\"input_hidden\" value=\"hidden_value\" />" " </div>" " <div id=\"input_month\">" " <label for=\"input_month\">month</label>" " <input type=\"month\" name=\"input_month\" id=\"input_month\" />" " </div>" " <div id=\"input_number\">" " <label for=\"input_number\">number</label>" " <input type=\"number\" name=\"input_number\" id=\"input_number\" />" " </div>" " <div id=\"input_password\">" " <label for=\"input_password\">password</label>" " <input type=\"password\" name=\"input_password\" id=\"input_password\" />" " </div>" " <div id=\"input_radio\">" " <label>radio</label>" " <input type=\"radio\" name=\"input_radio\" id=\"input_radio_1\" value=\"1\" />" " <label for=\"input_radio_1\">1</label>" " <input type=\"radio\" name=\"input_radio\" id=\"input_radio_2\" value=\"2\" />" " <label for=\"input_radio_2\">2</label>" " </div>" " <div id=\"input_range\">" " <label for=\"input_range\">range</label>" " <input type=\"range\" name=\"input_range\" id=\"input_range\" />" " </div>" " <div id=\"input_search\">" " <label for=\"input_search\">search</label>" " <input type=\"search\" name=\"input_search\" id=\"input_search\" />" " </div>" " <div id=\"input_tel\">" " <label for=\"input_tel\">tel</label>" " <input type=\"tel\" name=\"input_tel\" id=\"input_tel\" />" " </div>" " <div id=\"input_text\">" " <label for=\"input_text\">text</label>" " <input type=\"text\" name=\"input_text\" id=\"input_text\" />" " </div>" " <div id=\"input_time\">" " <label for=\"input_time\">time</label>" " <input type=\"time\" name=\"input_time\" id=\"input_time\" />" " </div>" " <div id=\"input_url\">" " <label for=\"input_url\">url</label>" " <input type=\"url\" name=\"input_url\" id=\"input_url\" />" " </div>" " <div id=\"input_week\">" " <label for=\"input_week\">week</label>" " <input type=\"week\" name=\"input_week\" id=\"input_week\" />" " </div>" " <div id=\"select\">" " <label for=\"select\">select</label>" " <select name=\"select\" id=\"select\">" " <option value=\"one\">one</option>" " <option value=\"two\">two</option>" " <option value=\"three\">three</option>" " </select>" " </div>" " <div id=\"select_multiple\">" " <label for=\"select_multiple\">select (multiple)</label>" " <select name=\"select_multiple\" id=\"select_multiple\" multiple=\"multiple\">" " <option value=\"one\">one</option>" " <option value=\"two\">two</option>" " <option value=\"three\">three</option>" " </select>" " </div>" " <input type=\"submit\">"; body = string("<html><body><h1>Example form</h1>" "<h2>application/x-www-form-urlencoded</h2>" "<form action=\"\" method=\"post\" enctype=\"application/x-www-form-urlencoded\">" , form_elements, "</form>" "<h2>multipart/form-data</h2>" "<form action=\"\" method=\"post\" enctype=\"multipart/form-data\">" , form_elements, "</form>" "<h2>text/plain</h2>" "<form action=\"\" method=\"post\" enctype=\"text/plain\">" , form_elements, "</form>" "</body></html>"); response = array( string("200 OK"), array(string("Content-type"), string("text/html; charset=utf-8")), array(body) ); return response; }
// storage for these rings is row-major, which is reflected in these iterator functions Iterator rowBegin(size_t row) { return Iterator(array() + row * numColumns(), 1); }
main() { double height = 3.0, width = 200.0; array x=array(0 , width , 100 ); // start,stop,npoint plot << x << (cos(x/5)+sin(x/7))*height/4 << "\n" ; }
void UnitTestDynamicArray::DoTest() { UNIT_TEST_BLOCK_START(); Dia::Core::Containers::DynamicArray<int> array(3); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array.At(0) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_POSITIVE(array.Capacity() == 3, "DynamicArray()"); UNIT_TEST_POSITIVE(array.Size() == 0, "DynamicArray()"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; UNIT_TEST_ASSERT_EXPECTED_START(); int* ptr = NULL; Dia::Core::Containers::DynamicArray<int> array0(ptr, 3); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array1(&cArray1[0], 3); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array2(&cArray2[0], 3); UNIT_TEST_POSITIVE(array2.Capacity() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(2) == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); int cArray3[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> array3(&cArray3[0], 2); UNIT_TEST_POSITIVE(array3.Capacity() == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(1) == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(tempArray1); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray(ConstReference data, unsigned int _size)"); int cArray3[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray3(cArray3, 2); Dia::Core::Containers::DynamicArray<int> array3(tempArray3); UNIT_TEST_POSITIVE(array3.IsFull(), "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Capacity() == 2, "DynamicArray(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(1) == 2, "DynamicArray(ConstReference data, unsigned int _size)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(tempArray1); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.Capacity() == 5, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.Size() == 5, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(3) == 4, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(4) == 5, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray(cArray, 5); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(tempArray, 2, 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(tempArray, 5, 2); UNIT_TEST_ASSERT_EXPECTED_END(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(tempArray1, 1, 3); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(0) == 2, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(1) == 3, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(2) == 4, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array2(tempArray2, 1, 2); UNIT_TEST_POSITIVE(array2.IsFull(), "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements"); UNIT_TEST_POSITIVE(array2.Capacity() == 2, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.At(0) == 2, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.At(1) == 3, "DynamicArray(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int>::ConstIterator iter1(tempArray1.Begin()); Dia::Core::Containers::DynamicArray<int> array1(3, iter1); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(Iterator begin)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(Iterator begin)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); int cArray2[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 2); Dia::Core::Containers::DynamicArray<int> array2(3, tempArray2.BeginConst()); UNIT_TEST_POSITIVE(!array2.IsFull(), "DynamicArray(Iterator begin)"); UNIT_TEST_POSITIVE(array2.Capacity() == 3, "DynamicArray(Iterator begin)"); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray<T, size>::DynamicArray ( Iterator begin )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(3, tempArray1.EndConst()); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray(ConstReverseIterator begin)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray(ConstReverseIterator begin)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(0) == 3, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(2) == 1, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); int cArray2[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 2); Dia::Core::Containers::DynamicArray<int> array2(3, tempArray2.EndConst()); UNIT_TEST_POSITIVE(!array2.IsFull(), "DynamicArray(ConstReverseIterator begin)"); UNIT_TEST_POSITIVE(array2.Capacity() == 3, "DynamicArray(ConstReverseIterator begin)"); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array2.At(0) == 2, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array2.At(1) == 1, "DynamicArray<T, size>::DynamicArray ( ConstReverseIterator iter begin )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class AboveTwoFilter { public: bool Evaluate(const int& currentIter)const { return (currentIter > 2); }; }; AboveTwoFilter filter1; int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(5, tempArray1.BeginConst(), filter1); UNIT_TEST_POSITIVE(!array1.IsFull(), "DynamicArray(ConstIterator& iter, const EvaluateFunctor& filter)"); UNIT_TEST_POSITIVE(array1.Capacity() == 5, "DynamicArray(ConstIterator& iter, const EvaluateFunctor& filter)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray ( ConstIterator& iter, const EvaluateFunctor& filter )"); UNIT_TEST_POSITIVE(array1.At(0) == 3, "DynamicArray<T, size>::DynamicArray ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(1) == 4, "DynamicArray<T, size>::DynamicArray ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(2) == 5, "DynamicArray<T, size>::DynamicArray ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(3) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(4) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; UNIT_TEST_ASSERT_EXPECTED_START(); int* ptr = NULL; Dia::Core::Containers::DynamicArray<int> array0(3); array0.Assign(ptr, 3); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(&cArray1[0], 10); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(&cArray1[0], 3); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(&cArray2[0], 3); UNIT_TEST_POSITIVE(array2.IsFull(), "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.Capacity() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array2.At(2) == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); int cArray3[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> array3(3); array3.Assign(&cArray3[0], 2); UNIT_TEST_POSITIVE(!array3.IsFull(), "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Capacity() == 3, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(1) == 2, "DynamicArray.Assign(ConstPointer pData, unsigned int _size)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(cArray1, 10); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> tempArray1; tempArray1.Reserve(3); tempArray1.Assign(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(tempArray1); UNIT_TEST_POSITIVE(array1.IsFull(), "DynamicArray.Assign(ConstReference pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Capacity() == 3, "DynamicArray.Assign(ConstReference pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); int cArray3[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray3; tempArray3.Reserve(3); tempArray3.Assign(cArray3, 2); Dia::Core::Containers::DynamicArray<int> array3(tempArray3); UNIT_TEST_POSITIVE(!array3.IsFull(), "DynamicArray.Assign(ConstReference pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Capacity() == 3, "DynamicArray.Assign(ConstReference pData, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_POSITIVE(array3.At(1) == 2, "DynamicArray.Assign(ConstReference data, unsigned int _size)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1; array1.Reserve(5); array1.Assign(tempArray1); UNIT_TEST_POSITIVE(array1.Size() == 5, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(3) == 4, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array1.At(4) == 5, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(tempArray2); UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_POSITIVE(array2.At(2) == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs)"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray(cArray, 5); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray, 2, 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray, 5, 2); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray, 2, 10); UNIT_TEST_ASSERT_EXPECTED_END(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray1, 1, 3); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(0) == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(1) == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array1.At(2) == 4, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(tempArray2, 1, 2); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.At(0) == 2, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_POSITIVE(array2.At(1) == 3, "DynamicArray.Assign(const DynamicArray<T,_size>& rhs, unsigned int startIndex, unsigned int numberElements)"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray1.BeginConst()); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); int cArray2[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 2); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(tempArray2.BeginConst()); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray<T, size>::DynamicArray.Assign ( Iterator begin )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[3] = {1, 2, 3}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 3); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Assign(tempArray1.EndConst()); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(0) == 3, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array1.At(2) == 1, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); int cArray2[2] = {1, 2}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 2); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Assign(tempArray2.EndConst()); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array2.At(0) == 2, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_POSITIVE(array2.At(1) == 1, "DynamicArray<T, size>::DynamicArray.Assign ( ConstReverseIterator iter begin )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class AboveTwoFilter { public: bool Evaluate(const int& currentIter)const { return (currentIter > 2); }; }; AboveTwoFilter filter1; int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(5); array1.Assign(tempArray1.BeginConst(), filter1); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray<T, size>::DynamicArray.Assign ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(0) == 3, "DynamicArray<T, size>::DynamicArray.Assign ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(1) == 4, "DynamicArray<T, size>::DynamicArray.Assign ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_POSITIVE(array1.At(2) == 5, "DynamicArray<T, size>::DynamicArray.Assign ( ConstIterator& iter, const EvaluateFunctor<T, bool>* filter )"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(3) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(4) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array1(5); array1 = tempArray1; UNIT_TEST_POSITIVE(array1.Size() == 5, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(1) == 2, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(2) == 3, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(3) == 4, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array1.At(4) == 5, "DynamicArray opertor="); int cArray2[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> tempArray2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array2(3); array2 = tempArray2; UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array2.At(1) == 2, "DynamicArray opertor="); UNIT_TEST_POSITIVE(array2.At(2) == 3, "DynamicArray opertor="); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array2(array1); Dia::Core::Containers::DynamicArray<int> array3(array1, 1, 3); UNIT_TEST_POSITIVE(array1 == array2, "DynamicArray opertor=="); UNIT_TEST_NEGATIVE(array1 == array3, "DynamicArray opertor=="); UNIT_TEST_POSITIVE(array1 != array3, "DynamicArray opertor!="); UNIT_TEST_NEGATIVE(array1 != array2, "DynamicArray opertor!="); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 5); UNIT_TEST_ASSERT_EXPECTED_START(); int temp = array1[-1]; UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); int temp = array1[6]; UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); int temp = array1.At(-1); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); int temp = array1.At(6); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_POSITIVE(array1[0] == array1.At(0), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1[1] == array1.At(1), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1[2] == array1.At(2), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1[3] == array1.At(3), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1[4] == array1.At(4), "DynamicArray opertor[]"); UNIT_TEST_POSITIVE(array1.Front() == array1.At(0), "DynamicArray Front"); UNIT_TEST_POSITIVE(array1.Back() == array1.At(4), "DynamicArray Back"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 5); UNIT_TEST_POSITIVE(&array1[0] == array1.IteratorAt(0).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(&array1[1] == array1.IteratorAt(1).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(&array1[2] == array1.IteratorAt(2).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(&array1[3] == array1.IteratorAt(3).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(&array1[4] == array1.IteratorAt(4).Current(), "DynamicArray IteratorAt"); UNIT_TEST_POSITIVE(array1.Begin() == array1.IteratorAt(0), "DynamicArray Begin"); UNIT_TEST_POSITIVE(array1.BeginConst() == array1.IteratorAtConst(0), "DynamicArray BeginConst"); UNIT_TEST_POSITIVE(&array1[0] == array1.ReverseIteratorAt(0).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(&array1[1] == array1.ReverseIteratorAt(1).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(&array1[2] == array1.ReverseIteratorAt(2).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(&array1[3] == array1.ReverseIteratorAt(3).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(&array1[4] == array1.ReverseIteratorAt(4).Current(), "DynamicArray ReverseIteratorAt"); UNIT_TEST_POSITIVE(array1.End() == array1.ReverseIteratorAt(4), "DynamicArray End"); UNIT_TEST_POSITIVE(array1.EndConst() == array1.ReverseIteratorAtConst(4), "DynamicArray EndConst"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[10] = {1, 2, 3, 4, 5, 1, 3, 3, 3, 4}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(1) == 2, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(2) == 1, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(3) == 4, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(4) == 2, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(5) == 1, "DynamicArray FrequencyOfElement"); UNIT_TEST_POSITIVE(array1.FrequencyOfElement(6) == 0, "DynamicArray FrequencyOfElement"); Dia::Core::Containers::DynamicArray<int> arrayUnique(10); array1.UniqueElements(arrayUnique); UNIT_TEST_POSITIVE(arrayUnique.Size() == 5, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[0] == 1, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[1] == 2, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[2] == 3, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[3] == 4, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayUnique[4] == 5, "DynamicArray numberOfUniqueElements"); Dia::Core::Containers::DynamicArray<int> arrayFreqUnique(10); Dia::Core::Containers::DynamicArray<int> arrayFreq(10); array1.FrequencyUniqueElements(arrayFreqUnique, arrayFreq); UNIT_TEST_POSITIVE(arrayFreqUnique.Size() == 5, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[0] == 1, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[1] == 2, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[2] == 3, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[3] == 4, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreqUnique[4] == 5, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[0] == 2, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[1] == 1, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[2] == 4, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[3] == 2, "DynamicArray numberOfUniqueElements"); UNIT_TEST_POSITIVE(arrayFreq[4] == 1, "DynamicArray numberOfUniqueElements"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class IncreasingOrder { public: bool GreaterThen(const int& object1, const int& object2)const { return (object1 > object2); } bool LessThen(const int& object1, const int& object2)const { return (object1 < object2); } bool Equal(const int& object1, const int& object2)const { return (object1 == object2); } }; IncreasingOrder order; int cArray1[10] = {1, 2, 3, 4, 5, 1, 3, 3, 3, 4}; int cArray2[5] = {4, 2, 5, 1, 3}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); Dia::Core::Containers::DynamicArray<int> array2(cArray2, 5); Dia::Core::Containers::DynamicArray<int> array3(cArray1, 10); Dia::Core::Containers::DynamicArray<int> array4(cArray2, 5); array1.Sort(order); UNIT_TEST_POSITIVE(array1[0] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[1] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[2] == 2, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[3] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[4] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[5] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[6] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[7] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[8] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1[9] == 5, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array1.IsSorted(order), "DynamicArray Sort"); array2.Sort(order); UNIT_TEST_POSITIVE(array2[0] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2[1] == 2, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2[2] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2[3] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2[4] == 5, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array2.IsSorted(order), "DynamicArray Sort"); array3.Sort(); UNIT_TEST_POSITIVE(array3[0] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[1] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[2] == 2, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[3] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[4] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[5] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[6] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[7] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[8] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3[9] == 5, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array3.IsSorted(), "DynamicArray Sort"); array4.Sort(); UNIT_TEST_POSITIVE(array4[0] == 1, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4[1] == 2, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4[2] == 3, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4[3] == 4, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4[4] == 5, "DynamicArray Sort"); UNIT_TEST_POSITIVE(array4.IsSorted(), "DynamicArray Sort"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[5] = {1, 2, 3, 4, 5}; int cArray2[5] = {4, 2, 5, 1, 3}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 5); Dia::Core::Containers::DynamicArray<int> array2(cArray2, 5); array1.Swap(array2); UNIT_TEST_POSITIVE(array1[0] == 4, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array1[1] == 2, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array1[2] == 5, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array1[3] == 1, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array1[4] == 3, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[0] == 1, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[1] == 2, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[2] == 3, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[3] == 4, "DynamicArray Swap"); UNIT_TEST_POSITIVE(array2[4] == 5, "DynamicArray Swap"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[10] = {1, 2, 3, 4, 5, 6, 3, 4, 5, 7}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); class OneLess { public: bool Equal(const int& object1, const int& object2)const { return (object1 == (object2 - 1)); } }; OneLess oneLess; UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindBetweenIndex(5, -2, 3); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindBetweenIndex(5, 3, 1); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindBetweenIndex(5, 0, 17); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_POSITIVE(array1.FindIndex(5) == 4 , "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(7) == 9, "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(10) == -1, "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(5, 0, 7) == 4 , "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(5, 6, 9) == 8, "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(1, 6, 9) == -1, "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(5, oneLess) == 3 , "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(7, oneLess) == 5, "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindIndex(10, oneLess) == -1, "DynamicArray FindIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(5, oneLess, 0, 7) == 3 , "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(5, oneLess, 6, 9) == 7, "DynamicArray FindBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindBetweenIndex(1, oneLess, 6, 9) == -1, "DynamicArray FindBetweenIndex"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[10] = {1, 2, 3, 4, 5, 6, 3, 4, 5, 7}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); class OneLess { public: bool Equal(const int& object1, const int& object2)const { return (object1 == (object2 - 1)); } }; OneLess oneLess; UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindLastBetweenIndex(5, -2, 3); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindLastBetweenIndex(5, 3, 1); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_ASSERT_EXPECTED_START(); array1.FindLastBetweenIndex(5, 0, 17); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_POSITIVE(array1.FindLastIndex(5) == 8 , "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(3) == 6, "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(10) == -1, "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(4, 0, 7) == 7 , "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(5, 6, 9) == 8, "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(1, 6, 9) == -1, "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(5, oneLess) == 7 , "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(7, oneLess) == 5, "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastIndex(10, oneLess) == -1, "DynamicArray FindLastIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(5, oneLess, 0, 7) == 7 , "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(5, oneLess, 6, 9) == 7, "DynamicArray FindLastBetweenIndex"); UNIT_TEST_POSITIVE(array1.FindLastBetweenIndex(1, oneLess, 6, 9) == -1, "DynamicArray FindLastBetweenIndex"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); int cArray1[10] = {1, 2, 3, 4, 5, 6, 3, 4, 5, 7}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); array1.Sort(); class Equality { public: bool GreaterThen(const int& object1, const int& object2)const { return (object1 > object2); } bool LessThen(const int& object1, const int& object2)const { return (object1 < object2); } bool Equal(const int& object1, const int& object2)const { return (object1 == object2); } }; Equality equality; UNIT_TEST_POSITIVE(array1.IsSorted(), "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(5) == 6 , "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(3) == 2, "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(10) == -1, "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(4) == 5 , "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(5) == 7, "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(10) == -1, "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(5, equality) == 6 , "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(3, equality) == 2, "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindSortedIndex(10, equality) == -1, "DynamicArray FindSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(4, equality) == 5 , "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(5, equality) == 7, "DynamicArray FindLastSortedIndex"); UNIT_TEST_POSITIVE(array1.FindLastSortedIndex(10, equality) == -1, "DynamicArray FindLastSortedIndex"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class Eval { public: float Evaluate(const int& object1)const { return static_cast<float>(object1); }; }; Eval eval; int cArray1[10] = {1, 2, 3, 9, 5, 6, 3, 4, 5, 7}; Dia::Core::Containers::DynamicArray<int> array1(cArray1, 10); UNIT_TEST_POSITIVE(array1.HighestEvalutionIndex(eval) == 3, "DynamicArray HighestEvalutionIndex"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); class Foo { public: Foo(): mSomeData(true), mMoreData(21.0f){} bool SomeData(){return mSomeData;} float MoreData(){return mMoreData;} bool mSomeData; float mMoreData; }; Foo cArray1[3]; Dia::Core::Containers::DynamicArray<Foo> array1(cArray1, 3); cArray1[0].mSomeData = false; cArray1[0].mMoreData = 11.0f; UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(0).SomeData(), "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(1).SomeData(), "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(2).SomeData(), "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(0).MoreData() == 21.0f, "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(1).MoreData() == 21.0f, "DynamicArray Test Non primitive"); UNIT_TEST_POSITIVE(array1.At(2).MoreData() == 21.0f, "DynamicArray Test Non primitive"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Add(1); array1.AddDefault(); array1.Add(2); UNIT_TEST_POSITIVE(array1.Size() == 3, "DynamicArray Add"); UNIT_TEST_POSITIVE(array1.At(0) == 1, "DynamicArray Add"); UNIT_TEST_POSITIVE(array1.At(1) == 0, "DynamicArray AddDefault"); UNIT_TEST_POSITIVE(array1.At(2) == 2, "DynamicArray Add"); Dia::Core::Containers::DynamicArray<int> array2(3); array2.FillDefault(); UNIT_TEST_POSITIVE(array2.Size() == 3, "DynamicArray Add"); UNIT_TEST_POSITIVE(array2.At(0) == 0, "DynamicArray FillDefault"); UNIT_TEST_POSITIVE(array2.At(1) == 0, "DynamicArray FillDefault"); UNIT_TEST_POSITIVE(array2.At(2) == 0, "DynamicArray FillDefault"); Dia::Core::Containers::DynamicArray<int> array3(3); array3.Fill(11); UNIT_TEST_POSITIVE(array3.Size() == 3, "DynamicArray Add"); UNIT_TEST_POSITIVE(array3.At(0) == 11, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array3.At(1) == 11, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array3.At(2) == 11, "DynamicArray Fill"); Dia::Core::Containers::DynamicArray<int> array4(3); array4.FillDefault(); UNIT_TEST_POSITIVE(array4.Size() == 3, "DynamicArray Add"); UNIT_TEST_POSITIVE(array4.At(0) == 0, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array4.At(1) == 0, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array4.At(2) == 0, "DynamicArray Fill"); Dia::Core::Containers::DynamicArray<int> array5(5); array5.AddDefault(); array5.AddAt(1, 0); array5.AddAt(2, 1); array5.AddAt(3, 1); array5.AddAt(4, 3); UNIT_TEST_POSITIVE(array5.Size() == 5, "DynamicArray Add"); UNIT_TEST_POSITIVE(array5.At(0) == 1, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array5.At(1) == 3, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array5.At(2) == 2, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array5.At(3) == 4, "DynamicArray Fill"); UNIT_TEST_POSITIVE(array5.At(4) == 0, "DynamicArray Fill"); UNIT_TEST_BLOCK_END(); UNIT_TEST_BLOCK_START(); Dia::Core::Containers::DynamicArray<int> array1(3); array1.Fill(11); array1.Remove(); UNIT_TEST_POSITIVE(array1.Size() == 2, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array1.At(0) == 11, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array1.At(1) == 11, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array1.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array2(3); array2.Add(1); array2.Add(2); array2.Add(3); array2.RemoveAt(1); UNIT_TEST_POSITIVE(array2.Size() == 2, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array2.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array2.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array2.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array3(3); array3.Add(1); array3.Add(2); array3.Add(3); array3.RemoveFirst(2); UNIT_TEST_POSITIVE(array3.Size() == 2, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array3.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array3.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array3.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array4(3); array4.Add(1); array4.Add(2); array4.Add(3); array4.RemoveLast(2); UNIT_TEST_POSITIVE(array4.Size() == 2, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array4.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array4.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array4.At(2) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); Dia::Core::Containers::DynamicArray<int> array5(3); array5.Add(1); array5.Add(2); array5.Add(3); array5.RemoveAll(); UNIT_TEST_POSITIVE(array5.Size() == 0, "DynamicArray Remove"); Dia::Core::Containers::DynamicArray<int> array6(5); array6.Add(1); array6.Add(2); array6.Add(3); array6.Add(2); array6.Add(3); array6.RemoveAll(2); UNIT_TEST_POSITIVE(array6.Size() == 3, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array6.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array6.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array6.At(2) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array6.At(3) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); class Comparisson { public: bool Evaluate(const int&a)const { return (a == 2); }; }; Comparisson compare; Dia::Core::Containers::DynamicArray<int> array7(5); array7.Add(1); array7.Add(2); array7.Add(3); array7.Add(2); array7.Add(3); array7.RemoveAll(compare); UNIT_TEST_POSITIVE(array7.Size() == 3, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array7.At(0) == 1, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array7.At(1) == 3, "DynamicArray Remove"); UNIT_TEST_POSITIVE(array7.At(2) == 3, "DynamicArray Remove"); UNIT_TEST_ASSERT_EXPECTED_START(); bool test = (array7.At(3) == 0); UNIT_TEST_ASSERT_EXPECTED_END(); UNIT_TEST_BLOCK_END(); mState = kFinished; }
void AsiMS2000::selectCommand(int commandNum) { switch(commandNum) { case 0: accel(); break; case 1: aalign(); break; case 2: afcont(); break; case 3: aflim(); break; case 4: afocus(); break; case 5: afset(); break; case 6: afmove(); break; case 7: ahome(); break; case 8: aij(); break; case 9: array(); break; case 10: azero(); break; case 11: backlash(); break; case 12: bcustom(); break; case 13: benable(); break; case 14: build(); break; case 15: cdate(); break; case 16: cnts(); break; case 17: customa(); break; case 18: customb(); break; case 19: dack(); break; case 20: dump(); break; case 21: ensync(); break; case 22: epolarity(); break; case 23: error(); break; case 24: halt(); break; case 25: here(); break; case 26: home(); break; case 27: info(); break; case 28: joystick(); break; case 29: jsspd(); break; case 30: kadc(); break; case 31: kd(); break; case 32: ki(); break; case 33: kp(); break; case 34: lcd(); break; case 35: led(); break; case 36: lladdr(); break; case 37: load(); break; case 38: lock(); break; case 39: lockrg(); break; case 40: lockset(); break; case 41: maintain(); break; case 42: motctrl(); break; case 43: move(); break; case 44: movrel(); break; case 45: pcros(); break; case 46: pedal(); break; case 47: rbmode(); break; case 48: rdadc(); break; case 49: rdsbyte(); break; case 50: rdstat(); break; case 51: relock(); break; case 52: reset(); break; case 53: rt(); break; case 54: runaway(); break; case 55: saveset(); break; case 56: savepos(); break; case 57: scan(); break; case 58: scanr(); break; case 59: scanv(); break; case 60: secure(); break; case 61: sethome(); break; case 62: setlow(); break; case 63: setup(); break; case 64: si(); break; case 65: speed(); break; case 66: spin(); break; case 67: status(); break; case 68: stopbits(); break; case 69: ttl(); break; case 70: um(); break; case 71: units(); break; case 72: unlock(); break; case 73: vb(); break; case 74: vector(); break; case 75: version(); break; case 76: wait(); break; case 77: where(); break; case 78: who(); break; case 79: wrdac(); break; case 80: zero(); break; case 81: z2b(); break; case 82: zs(); break; case 83: overshoot(); break; } }
array array::copy() const { af_array *other = 0; AF_THROW(af_copy_array(other, arr)); return array(*other); }
Iterator columnBegin(size_t col) { return Iterator(array() + col, numColumns()); }
array array::as(af_dtype type) const { af_array out; AF_THROW(af_cast(&out, this->get(), type)); return array(out); }
ConstIterator columnBegin(size_t col) const { return ConstIterator(array() + col, numColumns()); }
QByteArray byteArray() const { return QByteArray(array(), size()); }
ConstIterator columnEnd(size_t col) const { return ConstIterator(array() + col + numRows() * numColumns(), numColumns()); }
hx::Object * alloc_array(int arg1) { Array<Dynamic> array(arg1,arg1); return array.GetPtr(); }
void save(Archive & archive) const { std::vector<T> array(data,data+N); archive( array ); }
// Shortcut arithmetic operators. // ------------------------------ /// U = U Field& operator =(const Field& U) { cf3_assert(size() == U.size()); array() = U.array(); return *this; }
void load(Archive & archive) { std::vector<T> array(N); archive( array ); std::memcpy(data, array.data(), sizeof(T)*N); }
bool CsvChunkLoader::loadChunk(boost::shared_ptr<Query>& query, size_t chunkIndex) { // Must do EOF check *before* nextImplicitChunkPosition() call, or // we risk stepping out of bounds. if (_csvParser.empty()) { int ch = ::getc(fp()); if (ch == EOF) { return false; } ::ungetc(ch, fp()); } // Reposition and make sure all is cool. nextImplicitChunkPosition(MY_CHUNK); enforceChunkOrder("csv loader"); // Initialize a chunk and chunk iterator for each attribute. Attributes const& attrs = schema().getAttributes(); size_t nAttrs = attrs.size(); vector< boost::shared_ptr<ChunkIterator> > chunkIterators(nAttrs); for (size_t i = 0; i < nAttrs; i++) { Address addr(i, _chunkPos); MemChunk& chunk = getLookaheadChunk(i, chunkIndex); chunk.initialize(array(), &schema(), addr, attrs[i].getDefaultCompressionMethod()); chunkIterators[i] = chunk.getIterator(query, ChunkIterator::NO_EMPTY_CHECK | ConstChunkIterator::SEQUENTIAL_WRITE); } char const *field = 0; int rc = 0; bool sawData = false; bool sawEof = false; while (!chunkIterators[0]->end()) { _column = 0; array()->countCell(); // Parse and write out a line's worth of fields. NB if you // have to 'continue;' after a writeItem() call, make sure the // iterator (and possibly the _column) gets incremented. // for (size_t i = 0; i < nAttrs; ++i) { try { // Handle empty tag... if (i == emptyTagAttrId()) { attrVal(i).setBool(true); chunkIterators[i]->writeItem(attrVal(i)); ++(*chunkIterators[i]); // ...but don't increment _column. continue; } // Parse out next input field. rc = _csvParser.getField(field); if (rc == CsvParser::END_OF_FILE) { sawEof = true; break; } if (rc == CsvParser::END_OF_RECORD) { // Got record terminator, but we have more attributes! throw USER_EXCEPTION(SCIDB_SE_IMPORT_ERROR, SCIDB_LE_OP_INPUT_TOO_FEW_FIELDS) << _csvParser.getFileOffset() << _csvParser.getRecordNumber() << _column; } if (rc > 0) { // So long as we never call _csvParser.setStrict(true), we should never see this. throw USER_EXCEPTION(SCIDB_SE_IMPORT_ERROR, SCIDB_LE_CSV_PARSE_ERROR) << _csvParser.getFileOffset() << _csvParser.getRecordNumber() << _column << csv_strerror(rc); } SCIDB_ASSERT(rc == CsvParser::OK); SCIDB_ASSERT(field); sawData = true; // Process input field. if (mightBeNull(field) && attrs[i].isNullable()) { int8_t missingReason = parseNullField(field); if (missingReason >= 0) { attrVal(i).setNull(missingReason); chunkIterators[i]->writeItem(attrVal(i)); ++(*chunkIterators[i]); _column += 1; continue; } } if (converter(i)) { Value v; v.setString(field); const Value* vp = &v; (*converter(i))(&vp, &attrVal(i), NULL); chunkIterators[i]->writeItem(attrVal(i)); } else { TypeId const &tid = typeIdOfAttr(i); if (attrs[i].isNullable() && (*field == '\0' || (iswhitespace(field) && IS_NUMERIC(tid)))) { // [csv2scidb compat] With csv2scidb, empty strings (or for numeric // fields, whitespace) became nulls if the target attribute was // nullable. We keep the same behavior. (We should *not* do this for // TSV, that format requires explicit nulls!) attrVal(i).setNull(); } else { StringToValue(tid, field, attrVal(i)); } chunkIterators[i]->writeItem(attrVal(i)); } } catch (Exception& ex) { _badField = field; _fileOffset = _csvParser.getFileOffset(); array()->handleError(ex, chunkIterators[i], i); } _column += 1; ++(*chunkIterators[i]); } if (sawEof) { break; } // We should be at EOL now, otherwise there are too many fields on this line. Post a // warning: it seems useful not to complain too loudly about this or to abort the load, but // we do want to mention it. // rc = _csvParser.getField(field); if (!_tooManyWarning && (rc != CsvParser::END_OF_RECORD)) { _tooManyWarning = true; query->postWarning(SCIDB_WARNING(SCIDB_LE_OP_INPUT_TOO_MANY_FIELDS) << _csvParser.getFileOffset() << _csvParser.getRecordNumber() << _column); } array()->completeShadowArrayRow(); // done with cell/record } for (size_t i = 0; i < nAttrs; i++) { if (chunkIterators[i]) { chunkIterators[i]->flush(); } } return sawData; }
array resize(const array &in, const dim_type odim0, const dim_type odim1, const interpType method) { af_array out = 0; AF_THROW(af_resize(&out, in.get(), odim0, odim1, method)); return array(out); }
void SCardReader::run() { SCARDCONTEXT context; SCARDHANDLE cardHandle; DWORD activeProtocol; DWORD oldEventState; LONG erv; erv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &context); if (SCARD_S_SUCCESS == erv) { LONG crv; crv = SCardConnect(context, (LPCSTR) m_name, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &cardHandle, &activeProtocol); do { if (SCARD_S_SUCCESS == crv) { SCARD_IO_REQUEST ioRecvPci; BYTE recvBuffer[32]; BYTE sendBuffer[] = {0xFF, 0xCA, 0x00, 0x00, 0x00}; DWORD recvLength = sizeof(recvBuffer); LONG trv; trv = SCardTransmit(cardHandle, SCARD_PCI_T0, sendBuffer, sizeof(sendBuffer),&ioRecvPci, recvBuffer, &recvLength); if (SCARD_S_SUCCESS == trv) { if (recvLength == 6 && recvBuffer[4] == 0x90 && recvBuffer[5] == 0x00) m_cardid = (int)recvBuffer[0] | (int)recvBuffer[1] << 8 | (int)recvBuffer[2] << 16 | (int)recvBuffer[3] << 24; std::cout << m_cardid << " card inserted." << std::endl; if (m_mode == TallyMode) // m_mode(DriverMode) 初始化为DriverMode { //load authentication key recvLength = sizeof(recvBuffer); BYTE loadKey[] = {0xFF, 0x82, 0x00, 0x00, 0x06, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; trv = SCardTransmit(cardHandle, SCARD_PCI_T0, loadKey, sizeof(loadKey), &ioRecvPci, recvBuffer, &recvLength); if (SCARD_S_SUCCESS == trv && recvLength == 2 && recvBuffer[0] == 0x90 && recvBuffer[1] == 0x00) { //authentication key recvLength = sizeof(recvBuffer); BYTE authentication[] = {0xFF, 0x86, 0x00, 0x00, 0x05, 0x01, 0x00, 0x08, 0x60, 0x00}; trv = SCardTransmit(cardHandle, SCARD_PCI_T0, authentication, sizeof(authentication), &ioRecvPci, recvBuffer, &recvLength); if (SCARD_S_SUCCESS == trv && recvLength == 2 && recvBuffer[0] == 0x90 && recvBuffer[1] == 0x00) { //read binary recvLength = sizeof(recvBuffer); BYTE read[] = {0xFF, 0xB0, 0x00, 0x08, 0x10}; trv = SCardTransmit(cardHandle, SCARD_PCI_T0, read, sizeof(read), &ioRecvPci, recvBuffer, &recvLength); if (SCARD_S_SUCCESS == trv && recvLength == 18 && recvBuffer[16] == 0x90 && recvBuffer[17] == 0x00) { QByteArray array((const char *)recvBuffer, 16); emit dataReady(QString::number(m_cardid), array); } else std::cerr << m_name << " : " << pcsc_stringify_error(trv) << std::endl; } else std::cerr << m_name << " : " << pcsc_stringify_error(trv) << std::endl; } else std::cerr << m_name << " : " << pcsc_stringify_error(trv) << std::endl; } else emit inserted(QString::number(m_cardid)); } else if (SCARD_E_NO_SMARTCARD == trv) std::cerr << m_name << " : " << pcsc_stringify_error(trv) << std::endl; else { std::cerr << m_name << " : " << pcsc_stringify_error(trv) << std::endl; break; } (void) SCardDisconnect(cardHandle, SCARD_RESET_CARD); } if (SCARD_S_SUCCESS == crv || SCARD_E_NO_SMARTCARD == crv) { SCARD_READERSTATE readerStates; LONG grv; readerStates.szReader = m_name; readerStates.dwCurrentState = SCARD_STATE_UNAWARE; grv = SCardGetStatusChange(context, INFINITE, &readerStates, 1); oldEventState = readerStates.dwEventState; do { if (SCARD_S_SUCCESS == grv) { if (readerStates.dwEventState != oldEventState) { //card inserted if ((SCARD_STATE_CHANGED & readerStates.dwEventState) && (SCARD_STATE_PRESENT & readerStates.dwEventState)) break; //card removed if ((SCARD_STATE_CHANGED & readerStates.dwEventState) && (SCARD_STATE_EMPTY & readerStates.dwEventState)) { removed(QString::number(m_cardid)); std::cout << m_cardid << " card removed." << std::endl; } } else QThread::usleep(500); } else if (SCARD_E_TIMEOUT == grv) QThread::sleep(1); else break; oldEventState = readerStates.dwEventState; readerStates.szReader = m_name; readerStates.dwCurrentState = SCARD_STATE_UNAWARE; grv = SCardGetStatusChange(context, INFINITE, &readerStates, 1); } while (true); //quit if fatal error occurs if (SCARD_S_SUCCESS != grv) break; } else { std::cerr << m_name << " : " << pcsc_stringify_error(crv) << std::endl; break; } crv = SCardConnect(context, (LPCSTR) m_name, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &cardHandle, &activeProtocol); } while(true); } else std::cerr << m_name << " : " << pcsc_stringify_error(erv) << std::endl; std::cout << m_name << " deamon thread has exit." << std::endl; }
array resize(const array &in, const float scale, const interpType method) { af_array out = 0; AF_THROW(af_resize(&out, in.get(), in.dims(0) * scale, in.dims(1) * scale, method)); return array(out); }
void ZDvidInfo::setFromJsonString(const std::string &str) { clear(); ZJsonObject rootObj; if (rootObj.decode(str)) { ZJsonObject obj; if (rootObj.hasKey("Extended")) { obj.set(rootObj["Extended"], ZJsonValue::SET_INCREASE_REF_COUNT); } else { obj = rootObj; } if (obj.hasKey(m_minPointKey)) { ZJsonArray array(obj[m_minPointKey], false); std::vector<int> startCoordinates = array.toIntegerArray(); if (startCoordinates.size() == 3) { m_startCoordinates.set(startCoordinates); } else { m_startCoordinates.set(0, 0, 0); } } if (obj.hasKey(m_maxPointKey)) { ZJsonArray array(obj[m_maxPointKey], false); std::vector<int> endCoordinates = array.toIntegerArray(); if (endCoordinates.size() == 3) { for (int i = 0; i < 3; ++i) { m_stackSize[i] = endCoordinates[i] - m_startCoordinates[i] + 1; } } else { for (int i = 0; i < 3; ++i) { m_stackSize[i] = 0; } } } if (obj.hasKey(m_blockMinIndexKey)) { ZJsonArray array(obj[m_blockMinIndexKey], false); std::vector<int> startBlockIndex = array.toIntegerArray(); if (startBlockIndex.size() == 3) { m_startBlockIndex.set(startBlockIndex); } else { m_startBlockIndex.set(0, 0, 0); } } if (obj.hasKey(m_blockMaxIndexKey)) { ZJsonArray array(obj[m_blockMaxIndexKey], false); std::vector<int> blockIndex = array.toIntegerArray(); if (blockIndex.size() == 3) { m_endBlockIndex.set(blockIndex); } else { m_endBlockIndex.set(0, 0, 0); } } if (obj.hasKey(m_blockSizeKey)) { ZJsonArray array(obj[m_blockSizeKey], false); m_blockSize = array.toIntegerArray(); if (m_blockSize.size() != 3) { m_blockSize.resize(m_defaultBlockSize); } } if (obj.hasKey(m_voxelSizeKey)) { ZJsonArray array(obj[m_voxelSizeKey], false); std::vector<double> resolution = array.toNumberArray(); if (resolution.size() != 3) { m_voxelResolution.setVoxelSize(1, 1, 1); m_voxelResolution.setUnit('p'); } else { m_voxelResolution.setVoxelSize( resolution[0], resolution[1], resolution[2]); } } if (obj.hasKey(m_voxelUnitKey)) { ZJsonArray array(obj[m_voxelUnitKey], false); std::string unit = ZJsonParser::stringValue(array.at(0)); if (!unit.empty()) { m_voxelResolution.setUnit(unit); } } } }
Json(const V & v) : Json(array(v.begin(), v.end())) {}