Changeset 1159:7fdaa05a69a1 in lemon for test/maps_test.cc
 Timestamp:
 09/13/12 11:56:19 (7 years ago)
 Branch:
 default
 Children:
 1160:00f8d9f9920d, 1401:cd72eae05bdf
 Parents:
 1153:4bb9e72e1a41 (diff), 1157:761fe0846f49 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.  Phase:
 public
 Files:

 2 edited
Legend:
 Unmodified
 Added
 Removed

test/maps_test.cc
r1057 r1159 104 104 NullMap<A,B> map1; 105 105 NullMap<A,B> map2 = map1; 106 ignore_unused_variable_warning(map2); 106 107 map1 = nullMap<A,B>(); 107 108 } … … 114 115 ConstMap<A,B> map2 = B(); 115 116 ConstMap<A,B> map3 = map1; 117 ignore_unused_variable_warning(map2,map3); 118 116 119 map1 = constMap<A>(B()); 117 120 map1 = constMap<A,B>(); … … 119 122 ConstMap<A,C> map4(C(1)); 120 123 ConstMap<A,C> map5 = map4; 124 ignore_unused_variable_warning(map5); 125 121 126 map4 = constMap<A>(C(2)); 122 127 map4.setAll(C(3)); … … 139 144 IdentityMap<A> map1; 140 145 IdentityMap<A> map2 = map1; 146 ignore_unused_variable_warning(map2); 147 141 148 map1 = identityMap<A>(); 142 149 … … 198 205 checkConcept<ReadMap<B,double>, CompMap>(); 199 206 CompMap map1 = CompMap(DoubleMap(),ReadMap<B,A>()); 207 ignore_unused_variable_warning(map1); 200 208 CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>()); 209 ignore_unused_variable_warning(map2); 201 210 202 211 SparseMap<double, bool> m1(false); m1[3.14] = true; … … 211 220 checkConcept<ReadMap<A,double>, CombMap>(); 212 221 CombMap map1 = CombMap(DoubleMap(), DoubleMap()); 222 ignore_unused_variable_warning(map1); 213 223 CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>()); 224 ignore_unused_variable_warning(map2); 214 225 215 226 check(combineMap(constMap<B,int,2>(), identityMap<B>(), &binc)[B()] == 3, … … 223 234 FunctorToMap<F> map1; 224 235 FunctorToMap<F> map2 = FunctorToMap<F>(F()); 236 ignore_unused_variable_warning(map2); 237 225 238 B b = functorToMap(F())[A()]; 239 ignore_unused_variable_warning(b); 226 240 227 241 checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >(); 228 242 MapToFunctor<ReadMap<A,B> > map = 229 243 MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>()); 244 ignore_unused_variable_warning(map); 230 245 231 246 check(functorToMap(&func)[A()] == 3, … … 245 260 ConvertMap<ReadMap<double, int>, double> >(); 246 261 ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true)); 262 ignore_unused_variable_warning(map1); 247 263 ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false)); 264 ignore_unused_variable_warning(map2); 265 248 266 } 249 267 
test/maps_test.cc
r1157 r1159 3 3 * This file is a part of LEMON, a generic C++ optimization library. 4 4 * 5 * Copyright (C) 200320 095 * Copyright (C) 20032010 6 6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 7 7 * (Egervary Research Group on Combinatorial Optimization, EGRES). … … 24 24 #include <lemon/maps.h> 25 25 #include <lemon/list_graph.h> 26 #include <lemon/smart_graph.h> 27 #include <lemon/adaptors.h> 28 #include <lemon/dfs.h> 29 #include <algorithm> 26 30 27 31 #include "test_tools.h" … … 35 39 36 40 class C { 37 int x;41 int _x; 38 42 public: 39 C(int _x) : x(_x) {} 43 C(int x) : _x(x) {} 44 int get() const { return _x; } 45 }; 46 inline bool operator<(C c1, C c2) { return c1.get() < c2.get(); } 47 inline bool operator==(C c1, C c2) { return c1.get() == c2.get(); } 48 49 C createC(int x) { return C(x); } 50 51 template <typename T> 52 class Less { 53 T _t; 54 public: 55 Less(T t): _t(t) {} 56 bool operator()(const T& t) const { return t < _t; } 40 57 }; 41 58 … … 53 70 54 71 int binc(int a, B) { return a+1; } 72 73 template <typename T> 74 class Sum { 75 T& _sum; 76 public: 77 Sum(T& sum) : _sum(sum) {} 78 void operator()(const T& t) { _sum += t; } 79 }; 55 80 56 81 typedef ReadMap<A, double> DoubleMap; … … 349 374 { 350 375 typedef std::vector<int> vec; 376 checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >(); 377 checkConcept<WriteMap<int, bool>, 378 LoggerBoolMap<std::back_insert_iterator<vec> > >(); 379 351 380 vec v1; 352 381 vec v2(10); … … 368 397 it != map2.end(); ++it ) 369 398 check(v1[i++] == *it, "Something is wrong with LoggerBoolMap"); 370 } 371 372 // CrossRefMap 373 { 399 374 400 typedef ListDigraph Graph; 375 401 DIGRAPH_TYPEDEFS(Graph); 402 Graph gr; 403 404 Node n0 = gr.addNode(); 405 Node n1 = gr.addNode(); 406 Node n2 = gr.addNode(); 407 Node n3 = gr.addNode(); 408 409 gr.addArc(n3, n0); 410 gr.addArc(n3, n2); 411 gr.addArc(n0, n2); 412 gr.addArc(n2, n1); 413 gr.addArc(n0, n1); 414 415 { 416 std::vector<Node> v; 417 dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run(); 418 419 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3, 420 "Something is wrong with LoggerBoolMap"); 421 } 422 { 423 std::vector<Node> v(countNodes(gr)); 424 dfs(gr).processedMap(loggerBoolMap(v.begin())).run(); 425 426 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3, 427 "Something is wrong with LoggerBoolMap"); 428 } 429 } 430 431 // IdMap, RangeIdMap 432 { 433 typedef ListDigraph Graph; 434 DIGRAPH_TYPEDEFS(Graph); 435 436 checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >(); 437 checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >(); 438 checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >(); 439 checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >(); 440 441 Graph gr; 442 IdMap<Graph, Node> nmap(gr); 443 IdMap<Graph, Arc> amap(gr); 444 RangeIdMap<Graph, Node> nrmap(gr); 445 RangeIdMap<Graph, Arc> armap(gr); 446 447 Node n0 = gr.addNode(); 448 Node n1 = gr.addNode(); 449 Node n2 = gr.addNode(); 450 451 Arc a0 = gr.addArc(n0, n1); 452 Arc a1 = gr.addArc(n0, n2); 453 Arc a2 = gr.addArc(n2, n1); 454 Arc a3 = gr.addArc(n2, n0); 455 456 check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap"); 457 check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap"); 458 check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap"); 459 460 check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap"); 461 check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap"); 462 check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap"); 463 check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap"); 464 465 check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap"); 466 check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap"); 467 468 check(nrmap.size() == 3 && armap.size() == 4, 469 "Wrong RangeIdMap::size()"); 470 471 check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap"); 472 check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap"); 473 check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap"); 474 475 check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap"); 476 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap"); 477 check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap"); 478 check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap"); 479 480 check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap"); 481 check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap"); 482 483 gr.erase(n1); 484 485 if (nrmap[n0] == 1) nrmap.swap(n0, n2); 486 nrmap.swap(n2, n0); 487 if (armap[a1] == 1) armap.swap(a1, a3); 488 armap.swap(a3, a1); 489 490 check(nrmap.size() == 2 && armap.size() == 2, 491 "Wrong RangeIdMap::size()"); 492 493 check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap"); 494 check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap"); 495 496 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap"); 497 check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap"); 498 499 check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap"); 500 check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap"); 501 } 502 503 // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap 504 { 505 typedef ListGraph Graph; 506 GRAPH_TYPEDEFS(Graph); 507 508 checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >(); 509 checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >(); 510 checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >(); 511 checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >(); 512 checkConcept<ReadMap<Node, int>, InDegMap<Graph> >(); 513 checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >(); 514 515 Graph gr; 516 Node n0 = gr.addNode(); 517 Node n1 = gr.addNode(); 518 Node n2 = gr.addNode(); 519 520 gr.addEdge(n0,n1); 521 gr.addEdge(n1,n2); 522 gr.addEdge(n0,n2); 523 gr.addEdge(n2,n1); 524 gr.addEdge(n1,n2); 525 gr.addEdge(n0,n1); 526 527 for (EdgeIt e(gr); e != INVALID; ++e) { 528 check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap"); 529 check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap"); 530 } 531 532 check(mapCompare(gr, 533 sourceMap(orienter(gr, constMap<Edge, bool>(true))), 534 targetMap(orienter(gr, constMap<Edge, bool>(false)))), 535 "Wrong SourceMap or TargetMap"); 536 537 typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph; 538 Digraph dgr(gr, constMap<Edge, bool>(true)); 539 OutDegMap<Digraph> odm(dgr); 540 InDegMap<Digraph> idm(dgr); 541 542 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap"); 543 check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap"); 544 545 gr.addEdge(n2, n0); 546 547 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap"); 548 check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap"); 549 } 550 551 // CrossRefMap 552 { 553 typedef ListDigraph Graph; 554 DIGRAPH_TYPEDEFS(Graph); 376 555 377 556 checkConcept<ReadWriteMap<Node, int>, 378 557 CrossRefMap<Graph, Node, int> >(); 379 558 checkConcept<ReadWriteMap<Node, bool>, 559 CrossRefMap<Graph, Node, bool> >(); 560 checkConcept<ReadWriteMap<Node, double>, 561 CrossRefMap<Graph, Node, double> >(); 562 563 Graph gr; 564 typedef CrossRefMap<Graph, Node, char> CRMap; 565 CRMap map(gr); 566 567 Node n0 = gr.addNode(); 568 Node n1 = gr.addNode(); 569 Node n2 = gr.addNode(); 570 571 map.set(n0, 'A'); 572 map.set(n1, 'B'); 573 map.set(n2, 'C'); 574 575 check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0, 576 "Wrong CrossRefMap"); 577 check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1, 578 "Wrong CrossRefMap"); 579 check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2, 580 "Wrong CrossRefMap"); 581 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1, 582 "Wrong CrossRefMap::count()"); 583 584 CRMap::ValueIt it = map.beginValue(); 585 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && 586 it == map.endValue(), "Wrong value iterator"); 587 588 map.set(n2, 'A'); 589 590 check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A', 591 "Wrong CrossRefMap"); 592 check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap"); 593 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); 594 check(map('C') == INVALID && map.inverse()['C'] == INVALID, 595 "Wrong CrossRefMap"); 596 check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0, 597 "Wrong CrossRefMap::count()"); 598 599 it = map.beginValue(); 600 check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' && 601 it == map.endValue(), "Wrong value iterator"); 602 603 map.set(n0, 'C'); 604 605 check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A', 606 "Wrong CrossRefMap"); 607 check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap"); 608 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); 609 check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap"); 610 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1, 611 "Wrong CrossRefMap::count()"); 612 613 it = map.beginValue(); 614 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && 615 it == map.endValue(), "Wrong value iterator"); 616 } 617 618 // CrossRefMap 619 { 620 typedef SmartDigraph Graph; 621 DIGRAPH_TYPEDEFS(Graph); 622 623 checkConcept<ReadWriteMap<Node, int>, 624 CrossRefMap<Graph, Node, int> >(); 625 380 626 Graph gr; 381 627 typedef CrossRefMap<Graph, Node, char> CRMap; 382 628 typedef CRMap::ValueIterator ValueIt; 383 629 CRMap map(gr); 384 630 385 631 Node n0 = gr.addNode(); 386 632 Node n1 = gr.addNode(); 387 633 Node n2 = gr.addNode(); 388 634 389 635 map.set(n0, 'A'); 390 636 map.set(n1, 'B'); … … 404 650 } 405 651 652 // Iterable bool map 653 { 654 typedef SmartGraph Graph; 655 typedef SmartGraph::Node Item; 656 657 typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm; 658 checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>(); 659 660 const int num = 10; 661 Graph g; 662 Ibm map0(g, true); 663 std::vector<Item> items; 664 for (int i = 0; i < num; ++i) { 665 items.push_back(g.addNode()); 666 } 667 668 Ibm map1(g, true); 669 int n = 0; 670 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 671 check(map1[static_cast<Item>(it)], "Wrong TrueIt"); 672 ++n; 673 } 674 check(n == num, "Wrong number"); 675 676 n = 0; 677 for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { 678 check(map1[static_cast<Item>(it)], "Wrong ItemIt for true"); 679 ++n; 680 } 681 check(n == num, "Wrong number"); 682 check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt"); 683 check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false"); 684 685 map1[items[5]] = true; 686 687 n = 0; 688 for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { 689 check(map1[static_cast<Item>(it)], "Wrong ItemIt for true"); 690 ++n; 691 } 692 check(n == num, "Wrong number"); 693 694 map1[items[num / 2]] = false; 695 check(map1[items[num / 2]] == false, "Wrong map value"); 696 697 n = 0; 698 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 699 check(map1[static_cast<Item>(it)], "Wrong TrueIt for true"); 700 ++n; 701 } 702 check(n == num  1, "Wrong number"); 703 704 n = 0; 705 for (Ibm::FalseIt it(map1); it != INVALID; ++it) { 706 check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true"); 707 ++n; 708 } 709 check(n == 1, "Wrong number"); 710 711 map1[items[0]] = false; 712 check(map1[items[0]] == false, "Wrong map value"); 713 714 map1[items[num  1]] = false; 715 check(map1[items[num  1]] == false, "Wrong map value"); 716 717 n = 0; 718 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 719 check(map1[static_cast<Item>(it)], "Wrong TrueIt for true"); 720 ++n; 721 } 722 check(n == num  3, "Wrong number"); 723 check(map1.trueNum() == num  3, "Wrong number"); 724 725 n = 0; 726 for (Ibm::FalseIt it(map1); it != INVALID; ++it) { 727 check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true"); 728 ++n; 729 } 730 check(n == 3, "Wrong number"); 731 check(map1.falseNum() == 3, "Wrong number"); 732 } 733 734 // Iterable int map 735 { 736 typedef SmartGraph Graph; 737 typedef SmartGraph::Node Item; 738 typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim; 739 740 checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>(); 741 742 const int num = 10; 743 Graph g; 744 Iim map0(g, 0); 745 std::vector<Item> items; 746 for (int i = 0; i < num; ++i) { 747 items.push_back(g.addNode()); 748 } 749 750 Iim map1(g); 751 check(map1.size() == 0, "Wrong size"); 752 753 for (int i = 0; i < num; ++i) { 754 map1[items[i]] = i; 755 } 756 check(map1.size() == num, "Wrong size"); 757 758 for (int i = 0; i < num; ++i) { 759 Iim::ItemIt it(map1, i); 760 check(static_cast<Item>(it) == items[i], "Wrong value"); 761 ++it; 762 check(static_cast<Item>(it) == INVALID, "Wrong value"); 763 } 764 765 for (int i = 0; i < num; ++i) { 766 map1[items[i]] = i % 2; 767 } 768 check(map1.size() == 2, "Wrong size"); 769 770 int n = 0; 771 for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) { 772 check(map1[static_cast<Item>(it)] == 0, "Wrong value"); 773 ++n; 774 } 775 check(n == (num + 1) / 2, "Wrong number"); 776 777 for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) { 778 check(map1[static_cast<Item>(it)] == 1, "Wrong value"); 779 ++n; 780 } 781 check(n == num, "Wrong number"); 782 783 } 784 785 // Iterable value map 786 { 787 typedef SmartGraph Graph; 788 typedef SmartGraph::Node Item; 789 typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm; 790 791 checkConcept<ReadWriteMap<Item, double>, Ivm>(); 792 793 const int num = 10; 794 Graph g; 795 Ivm map0(g, 0.0); 796 std::vector<Item> items; 797 for (int i = 0; i < num; ++i) { 798 items.push_back(g.addNode()); 799 } 800 801 Ivm map1(g, 0.0); 802 check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size"); 803 check(*map1.beginValue() == 0.0, "Wrong value"); 804 805 for (int i = 0; i < num; ++i) { 806 map1.set(items[i], static_cast<double>(i)); 807 } 808 check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size"); 809 810 for (int i = 0; i < num; ++i) { 811 Ivm::ItemIt it(map1, static_cast<double>(i)); 812 check(static_cast<Item>(it) == items[i], "Wrong value"); 813 ++it; 814 check(static_cast<Item>(it) == INVALID, "Wrong value"); 815 } 816 817 for (Ivm::ValueIt vit = map1.beginValue(); 818 vit != map1.endValue(); ++vit) { 819 check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit, 820 "Wrong ValueIt"); 821 } 822 823 for (int i = 0; i < num; ++i) { 824 map1.set(items[i], static_cast<double>(i % 2)); 825 } 826 check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size"); 827 828 int n = 0; 829 for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) { 830 check(map1[static_cast<Item>(it)] == 0.0, "Wrong value"); 831 ++n; 832 } 833 check(n == (num + 1) / 2, "Wrong number"); 834 835 for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) { 836 check(map1[static_cast<Item>(it)] == 1.0, "Wrong value"); 837 ++n; 838 } 839 check(n == num, "Wrong number"); 840 841 } 842 843 // Graph map utilities: 844 // mapMin(), mapMax(), mapMinValue(), mapMaxValue() 845 // mapFind(), mapFindIf(), mapCount(), mapCountIf() 846 // mapCopy(), mapCompare(), mapFill() 847 { 848 DIGRAPH_TYPEDEFS(SmartDigraph); 849 850 SmartDigraph g; 851 Node n1 = g.addNode(); 852 Node n2 = g.addNode(); 853 Node n3 = g.addNode(); 854 855 SmartDigraph::NodeMap<int> map1(g); 856 SmartDigraph::ArcMap<char> map2(g); 857 ConstMap<Node, A> cmap1 = A(); 858 ConstMap<Arc, C> cmap2 = C(0); 859 860 map1[n1] = 10; 861 map1[n2] = 5; 862 map1[n3] = 12; 863 864 // mapMin(), mapMax(), mapMinValue(), mapMaxValue() 865 check(mapMin(g, map1) == n2, "Wrong mapMin()"); 866 check(mapMax(g, map1) == n3, "Wrong mapMax()"); 867 check(mapMin(g, map1, std::greater<int>()) == n3, "Wrong mapMin()"); 868 check(mapMax(g, map1, std::greater<int>()) == n2, "Wrong mapMax()"); 869 check(mapMinValue(g, map1) == 5, "Wrong mapMinValue()"); 870 check(mapMaxValue(g, map1) == 12, "Wrong mapMaxValue()"); 871 872 check(mapMin(g, map2) == INVALID, "Wrong mapMin()"); 873 check(mapMax(g, map2) == INVALID, "Wrong mapMax()"); 874 875 check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()"); 876 check(mapMax(g, cmap2) == INVALID, "Wrong mapMax()"); 877 878 Arc a1 = g.addArc(n1, n2); 879 Arc a2 = g.addArc(n1, n3); 880 Arc a3 = g.addArc(n2, n3); 881 Arc a4 = g.addArc(n3, n1); 882 883 map2[a1] = 'b'; 884 map2[a2] = 'a'; 885 map2[a3] = 'b'; 886 map2[a4] = 'c'; 887 888 // mapMin(), mapMax(), mapMinValue(), mapMaxValue() 889 check(mapMin(g, map2) == a2, "Wrong mapMin()"); 890 check(mapMax(g, map2) == a4, "Wrong mapMax()"); 891 check(mapMin(g, map2, std::greater<int>()) == a4, "Wrong mapMin()"); 892 check(mapMax(g, map2, std::greater<int>()) == a2, "Wrong mapMax()"); 893 check(mapMinValue(g, map2, std::greater<int>()) == 'c', 894 "Wrong mapMinValue()"); 895 check(mapMaxValue(g, map2, std::greater<int>()) == 'a', 896 "Wrong mapMaxValue()"); 897 898 check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()"); 899 check(mapMax(g, cmap2) != INVALID, "Wrong mapMax()"); 900 check(mapMaxValue(g, cmap2) == C(0), "Wrong mapMaxValue()"); 901 902 check(mapMin(g, composeMap(functorToMap(&createC), map2)) == a2, 903 "Wrong mapMin()"); 904 check(mapMax(g, composeMap(functorToMap(&createC), map2)) == a4, 905 "Wrong mapMax()"); 906 check(mapMinValue(g, composeMap(functorToMap(&createC), map2)) == C('a'), 907 "Wrong mapMinValue()"); 908 check(mapMaxValue(g, composeMap(functorToMap(&createC), map2)) == C('c'), 909 "Wrong mapMaxValue()"); 910 911 // mapFind(), mapFindIf() 912 check(mapFind(g, map1, 5) == n2, "Wrong mapFind()"); 913 check(mapFind(g, map1, 6) == INVALID, "Wrong mapFind()"); 914 check(mapFind(g, map2, 'a') == a2, "Wrong mapFind()"); 915 check(mapFind(g, map2, 'e') == INVALID, "Wrong mapFind()"); 916 check(mapFind(g, cmap2, C(0)) == ArcIt(g), "Wrong mapFind()"); 917 check(mapFind(g, cmap2, C(1)) == INVALID, "Wrong mapFind()"); 918 919 check(mapFindIf(g, map1, Less<int>(7)) == n2, 920 "Wrong mapFindIf()"); 921 check(mapFindIf(g, map1, Less<int>(5)) == INVALID, 922 "Wrong mapFindIf()"); 923 check(mapFindIf(g, map2, Less<char>('d')) == ArcIt(g), 924 "Wrong mapFindIf()"); 925 check(mapFindIf(g, map2, Less<char>('a')) == INVALID, 926 "Wrong mapFindIf()"); 927 928 // mapCount(), mapCountIf() 929 check(mapCount(g, map1, 5) == 1, "Wrong mapCount()"); 930 check(mapCount(g, map1, 6) == 0, "Wrong mapCount()"); 931 check(mapCount(g, map2, 'a') == 1, "Wrong mapCount()"); 932 check(mapCount(g, map2, 'b') == 2, "Wrong mapCount()"); 933 check(mapCount(g, map2, 'e') == 0, "Wrong mapCount()"); 934 check(mapCount(g, cmap2, C(0)) == 4, "Wrong mapCount()"); 935 check(mapCount(g, cmap2, C(1)) == 0, "Wrong mapCount()"); 936 937 check(mapCountIf(g, map1, Less<int>(11)) == 2, 938 "Wrong mapCountIf()"); 939 check(mapCountIf(g, map1, Less<int>(13)) == 3, 940 "Wrong mapCountIf()"); 941 check(mapCountIf(g, map1, Less<int>(5)) == 0, 942 "Wrong mapCountIf()"); 943 check(mapCountIf(g, map2, Less<char>('d')) == 4, 944 "Wrong mapCountIf()"); 945 check(mapCountIf(g, map2, Less<char>('c')) == 3, 946 "Wrong mapCountIf()"); 947 check(mapCountIf(g, map2, Less<char>('a')) == 0, 948 "Wrong mapCountIf()"); 949 950 // MapIt, ConstMapIt 951 /* 952 These tests can be used after applying bugfix #330 953 typedef SmartDigraph::NodeMap<int>::MapIt MapIt; 954 typedef SmartDigraph::NodeMap<int>::ConstMapIt ConstMapIt; 955 check(*std::min_element(MapIt(map1), MapIt(INVALID)) == 5, 956 "Wrong NodeMap<>::MapIt"); 957 check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12, 958 "Wrong NodeMap<>::MapIt"); 959 960 int sum = 0; 961 std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum)); 962 check(sum == 27, "Wrong NodeMap<>::MapIt"); 963 std::for_each(ConstMapIt(map1), ConstMapIt(INVALID), Sum<int>(sum)); 964 check(sum == 54, "Wrong NodeMap<>::ConstMapIt"); 965 */ 966 967 // mapCopy(), mapCompare(), mapFill() 968 check(mapCompare(g, map1, map1), "Wrong mapCompare()"); 969 check(mapCompare(g, cmap2, cmap2), "Wrong mapCompare()"); 970 check(mapCompare(g, map1, shiftMap(map1, 0)), "Wrong mapCompare()"); 971 check(mapCompare(g, map2, scaleMap(map2, 1)), "Wrong mapCompare()"); 972 check(!mapCompare(g, map1, shiftMap(map1, 1)), "Wrong mapCompare()"); 973 974 SmartDigraph::NodeMap<int> map3(g, 0); 975 SmartDigraph::ArcMap<char> map4(g, 'a'); 976 977 check(!mapCompare(g, map1, map3), "Wrong mapCompare()"); 978 check(!mapCompare(g, map2, map4), "Wrong mapCompare()"); 979 980 mapCopy(g, map1, map3); 981 mapCopy(g, map2, map4); 982 983 check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()"); 984 check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()"); 985 986 Undirector<SmartDigraph> ug(g); 987 Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x'); 988 Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14); 989 990 check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()"); 991 check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()"); 992 check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()"); 993 check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()"); 994 995 mapCopy(g, map2, umap1); 996 997 check(mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()"); 998 check(mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()"); 999 check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()"); 1000 check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()"); 1001 1002 mapCopy(g, map2, umap1); 1003 mapCopy(g, umap1, map2); 1004 mapCopy(ug, map2, umap1); 1005 mapCopy(ug, umap1, map2); 1006 1007 check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()"); 1008 mapCopy(ug, umap1, umap2); 1009 check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()"); 1010 1011 check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()"); 1012 mapFill(g, map1, 2); 1013 check(mapCompare(g, constMap<Node>(2), map1), "Wrong mapFill()"); 1014 1015 check(!mapCompare(g, map2, constMap<Arc>('z')), "Wrong mapCompare()"); 1016 mapCopy(g, constMap<Arc>('z'), map2); 1017 check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()"); 1018 } 1019 406 1020 return 0; 407 1021 }
Note: See TracChangeset
for help on using the changeset viewer.