Back to home page

LXR
 
 

    

File indexing completed on 2025-05-11 08:24:50 

0001 /* SPDX-License-Identifier: BSD-2-Clause */
0002 
0003 /**
0004  * @file
0005  *
0006  * @ingroup ScoreRbtreeUnitRbtree
0007  */
0008 
0009 /*
0010  * Copyright (C) 2021 embedded brains GmbH & Co. KG
0011  * Copyright (C) 2010 Gedare Bloom
0012  *
0013  * Redistribution and use in source and binary forms, with or without
0014  * modification, are permitted provided that the following conditions
0015  * are met:
0016  * 1. Redistributions of source code must retain the above copyright
0017  *    notice, this list of conditions and the following disclaimer.
0018  * 2. Redistributions in binary form must reproduce the above copyright
0019  *    notice, this list of conditions and the following disclaimer in the
0020  *    documentation and/or other materials provided with the distribution.
0021  *
0022  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
0023  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
0024  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
0025  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
0026  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
0027  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
0028  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
0029  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
0030  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
0031  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
0032  * POSSIBILITY OF SUCH DAMAGE.
0033  */
0034 
0035 /*
0036  * This file is part of the RTEMS quality process and was automatically
0037  * generated.  If you find something that needs to be fixed or
0038  * worded better please post a report or patch to an RTEMS mailing list
0039  * or raise a bug report:
0040  *
0041  * https://www.rtems.org/bugs.html
0042  *
0043  * For information on updating and regenerating please refer to the How-To
0044  * section in the Software Requirements Engineering chapter of the
0045  * RTEMS Software Engineering manual.  The manual is provided as a part of
0046  * a release.  For development sources please refer to the online
0047  * documentation at:
0048  *
0049  * https://docs.rtems.org
0050  */
0051 
0052 #ifdef HAVE_CONFIG_H
0053 #include "config.h"
0054 #endif
0055 
0056 #include <string.h>
0057 #include <rtems/score/rbtreeimpl.h>
0058 
0059 #include <rtems/test.h>
0060 
0061 /**
0062  * @defgroup ScoreRbtreeUnitRbtree spec:/score/rbtree/unit/rbtree
0063  *
0064  * @ingroup TestsuitesUnitNoClock0
0065  *
0066  * @brief Unit tests for the red-black tree implementation.
0067  *
0068  * The red-black trees are used by various handlers for priority queues and the
0069  * timers.
0070  *
0071  * This test case performs the following actions:
0072  *
0073  * - Call _RBTree_Initialize_one() and check the tree properties.
0074  *
0075  *   - Check that the tree is not emtpy.
0076  *
0077  *   - Check that the tree root is is the only node.
0078  *
0079  *   - Check that the node is not off the tree.
0080  *
0081  *   - Check that the node has no left child.
0082  *
0083  *   - Check that the node has no right child.
0084  *
0085  *   - Check that the node has no parent.
0086  *
0087  *   - Check that the node has no successor.
0088  *
0089  *   - Check that the node has no predecessor.
0090  *
0091  *   - Check that the minimum node is the node.
0092  *
0093  *   - Check that the maximum node is the node.
0094  *
0095  *   - Check that the tree is emtpy after extraction of the node.
0096  *
0097  * - Call _RBTree_Insert_inline() and check the return status for a sample set
0098  *   of nodes.
0099  *
0100  *   - Insert the first node.  Check that it is the new minimum node.
0101  *
0102  *   - Insert the second node.  Check that it is not the new minimum node.
0103  *
0104  *   - Insert the third node.  Check that it is the new minimum node.
0105  *
0106  * - Call _RBTree_Insert_inline() and _RBTree_Extract() for a sample set of
0107  *   trees.
0108  *
0109  * @{
0110  */
0111 
0112 typedef struct {
0113   int         id;
0114   int         key;
0115   RBTree_Node Node;
0116 } TestNode;
0117 
0118 static TestNode node_array[ 100 ];
0119 
0120 static int Color( const RBTree_Node *n )
0121 {
0122   return RTEMS_RB_COLOR( n, Node );
0123 }
0124 
0125 static bool Less( const void *left, const RBTree_Node *right )
0126 {
0127   const int       *the_left;
0128   const TestNode *the_right;
0129 
0130   the_left = left;
0131   the_right = RTEMS_CONTAINER_OF( right, TestNode, Node );
0132 
0133   return *the_left < the_right->key;
0134 }
0135 
0136 /*
0137  * recursively checks tree. if the tree is built properly it should only
0138  * be a depth of 7 function calls for 100 entries in the tree.
0139  */
0140 static int VerifyTree( RBTree_Node *root )
0141 {
0142   RBTree_Node *ln;
0143   RBTree_Node *rn;
0144   TestNode    *tn;
0145   TestNode    *ltn;
0146   TestNode    *rtn;
0147   int          lh;
0148   int          rh;
0149 
0150   if ( root == NULL ) {
0151     return 1;
0152   }
0153 
0154   ln = _RBTree_Left( root );
0155   rn = _RBTree_Right( root );
0156   tn = RTEMS_CONTAINER_OF( root, TestNode, Node );
0157   ltn = RTEMS_CONTAINER_OF( ln, TestNode, Node );
0158   rtn = RTEMS_CONTAINER_OF( rn, TestNode, Node );
0159 
0160   /* Consecutive red links */
0161   if (
0162     Color( root ) == RTEMS_RB_RED &&
0163     ( ( ln != NULL && Color( ln ) == RTEMS_RB_RED ) ||
0164       ( rn != NULL && Color( rn ) == RTEMS_RB_RED ) )
0165   ) {
0166     return -1;
0167   }
0168 
0169   lh = VerifyTree ( ln );
0170   rh = VerifyTree ( rn );
0171 
0172   if ( lh == -1 || rh == -1 ) {
0173     return -1;
0174   }
0175 
0176   /* Black height mismatch */
0177   if ( lh != rh ) {
0178     return -1;
0179   }
0180 
0181   /* Invalid binary search tree */
0182   if (
0183     ( ln != NULL && tn->key != ltn->key && !Less( &ltn->key, root ) ) ||
0184     ( rn != NULL && tn->key != rtn->key && !Less( &tn->key, rn ) )
0185   ) {
0186     return -1;
0187   }
0188 
0189   /* Only count black links */
0190   return Color( root ) == RTEMS_RB_BLACK ? lh + 1 : lh;
0191 }
0192 
0193 #define TN( i ) &node_array[ i ].Node
0194 
0195 typedef struct {
0196   int                key;
0197   const RBTree_Node *parent;
0198   const RBTree_Node *left;
0199   const RBTree_Node *right;
0200   int                color;
0201 } TestNodeDescription;
0202 
0203 typedef struct {
0204   int                        current;
0205   int                        count;
0206   const TestNodeDescription *tree;
0207 } VisitorContext;
0208 
0209 static bool VisitNodes(
0210   const RBTree_Node *node,
0211   void              *visitor_arg
0212 )
0213 {
0214   VisitorContext            *ctx;
0215   const TestNodeDescription *td;
0216   const TestNode            *tn;
0217 
0218   ctx = visitor_arg;
0219   td = &ctx->tree[ ctx->current ];
0220   tn = RTEMS_CONTAINER_OF( node, TestNode, Node );
0221 
0222   T_lt_int( ctx->current, ctx->count );
0223 
0224   T_eq_int( td->key, tn->key );
0225 
0226   if ( td->parent == NULL ) {
0227     T_true( _RBTree_Is_root( &tn->Node ) );
0228   } else {
0229     T_eq_ptr( td->parent, _RBTree_Parent( &tn->Node ) );
0230   }
0231 
0232   T_eq_ptr( td->left, _RBTree_Left( &tn->Node ) );
0233   T_eq_ptr( td->right, _RBTree_Right( &tn->Node ) );
0234   T_eq_int( td->color, Color( &tn->Node ) );
0235 
0236   ++ctx->current;
0237 
0238   return false;
0239 }
0240 
0241 static const TestNodeDescription random_ops_tree_unique_1[] = {
0242   { 0, NULL, NULL, NULL, RTEMS_RB_BLACK }
0243 };
0244 
0245 static const TestNodeDescription random_ops_tree_multiple_1[] = {
0246   { 0, NULL, NULL, NULL, RTEMS_RB_BLACK }
0247 };
0248 
0249 static const TestNodeDescription random_ops_tree_unique_2[] = {
0250 };
0251 
0252 static const TestNodeDescription random_ops_tree_multiple_2[] = {
0253 };
0254 
0255 static const TestNodeDescription random_ops_tree_unique_3[] = {
0256   { 2, NULL, NULL, NULL, RTEMS_RB_BLACK }
0257 };
0258 
0259 static const TestNodeDescription random_ops_tree_multiple_3[] = {
0260   { 1, NULL, NULL, NULL, RTEMS_RB_BLACK }
0261 };
0262 
0263 static const TestNodeDescription random_ops_tree_unique_4[] = {
0264   { 0, TN( 3 ), NULL, NULL, RTEMS_RB_RED },
0265   { 3, NULL, TN( 0 ), NULL, RTEMS_RB_BLACK }
0266 };
0267 
0268 static const TestNodeDescription random_ops_tree_multiple_4[] = {
0269   { 0, NULL, NULL, TN( 3 ), RTEMS_RB_BLACK },
0270   { 1, TN( 0 ), NULL, NULL, RTEMS_RB_RED }
0271 };
0272 
0273 static const TestNodeDescription random_ops_tree_unique_5[] = {
0274   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0275   { 1, NULL, TN( 0 ), TN( 4 ), RTEMS_RB_BLACK },
0276   { 4, TN( 1 ), NULL, NULL, RTEMS_RB_RED }
0277 };
0278 
0279 static const TestNodeDescription random_ops_tree_multiple_5[] = {
0280   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0281   { 0, NULL, TN( 0 ), TN( 4 ), RTEMS_RB_BLACK },
0282   { 2, TN( 1 ), NULL, NULL, RTEMS_RB_RED }
0283 };
0284 
0285 static const TestNodeDescription random_ops_tree_unique_6[] = {
0286   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0287   { 2, NULL, TN( 0 ), NULL, RTEMS_RB_BLACK }
0288 };
0289 
0290 static const TestNodeDescription random_ops_tree_multiple_6[] = {
0291   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0292   { 1, NULL, TN( 0 ), NULL, RTEMS_RB_BLACK }
0293 };
0294 
0295 static const TestNodeDescription random_ops_tree_unique_7[] = {
0296   { 0, TN( 2 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0297   { 1, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0298   { 2, NULL, TN( 0 ), TN( 5 ), RTEMS_RB_BLACK },
0299   { 4, TN( 5 ), NULL, NULL, RTEMS_RB_RED },
0300   { 5, TN( 2 ), TN( 4 ), NULL, RTEMS_RB_BLACK }
0301 };
0302 
0303 static const TestNodeDescription random_ops_tree_multiple_7[] = {
0304   { 0, TN( 2 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0305   { 0, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0306   { 1, NULL, TN( 0 ), TN( 4 ), RTEMS_RB_BLACK },
0307   { 2, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0308   { 2, TN( 2 ), TN( 5 ), NULL, RTEMS_RB_BLACK }
0309 };
0310 
0311 static const TestNodeDescription random_ops_tree_unique_8[] = {
0312   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_BLACK },
0313   { 1, NULL, TN( 0 ), TN( 6 ), RTEMS_RB_BLACK },
0314   { 5, TN( 6 ), NULL, NULL, RTEMS_RB_RED },
0315   { 6, TN( 1 ), TN( 5 ), NULL, RTEMS_RB_BLACK }
0316 };
0317 
0318 static const TestNodeDescription random_ops_tree_multiple_8[] = {
0319   { 0, TN( 5 ), NULL, TN( 0 ), RTEMS_RB_BLACK },
0320   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0321   { 2, NULL, TN( 1 ), TN( 6 ), RTEMS_RB_BLACK },
0322   { 3, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK }
0323 };
0324 
0325 static const TestNodeDescription random_ops_tree_unique_9[] = {
0326   { 1, TN( 2 ), NULL, NULL, RTEMS_RB_BLACK },
0327   { 2, TN( 6 ), TN( 1 ), TN( 4 ), RTEMS_RB_RED },
0328   { 4, TN( 2 ), NULL, TN( 5 ), RTEMS_RB_BLACK },
0329   { 5, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0330   { 6, NULL, TN( 2 ), TN( 7 ), RTEMS_RB_BLACK },
0331   { 7, TN( 6 ), NULL, TN( 8 ), RTEMS_RB_BLACK },
0332   { 8, TN( 7 ), NULL, NULL, RTEMS_RB_RED }
0333 };
0334 
0335 static const TestNodeDescription random_ops_tree_multiple_9[] = {
0336   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_BLACK },
0337   { 1, TN( 6 ), TN( 1 ), TN( 4 ), RTEMS_RB_RED },
0338   { 2, TN( 2 ), NULL, TN( 5 ), RTEMS_RB_BLACK },
0339   { 2, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0340   { 3, NULL, TN( 2 ), TN( 7 ), RTEMS_RB_BLACK },
0341   { 3, TN( 6 ), NULL, TN( 8 ), RTEMS_RB_BLACK },
0342   { 4, TN( 7 ), NULL, NULL, RTEMS_RB_RED }
0343 };
0344 
0345 static const TestNodeDescription random_ops_tree_unique_10[] = {
0346   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_BLACK },
0347   { 2, TN( 6 ), TN( 0 ), TN( 4 ), RTEMS_RB_RED },
0348   { 3, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0349   { 4, TN( 2 ), TN( 3 ), NULL, RTEMS_RB_BLACK },
0350   { 6, NULL, TN( 2 ), TN( 8 ), RTEMS_RB_BLACK },
0351   { 8, TN( 6 ), NULL, NULL, RTEMS_RB_BLACK }
0352 };
0353 
0354 static const TestNodeDescription random_ops_tree_multiple_10[] = {
0355   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_BLACK },
0356   { 1, TN( 6 ), TN( 0 ), TN( 4 ), RTEMS_RB_RED },
0357   { 1, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0358   { 2, TN( 2 ), TN( 3 ), NULL, RTEMS_RB_BLACK },
0359   { 3, NULL, TN( 2 ), TN( 8 ), RTEMS_RB_BLACK },
0360   { 4, TN( 6 ), NULL, NULL, RTEMS_RB_BLACK }
0361 };
0362 
0363 static const TestNodeDescription random_ops_tree_unique_11[] = {
0364   { 2, TN( 6 ), NULL, NULL, RTEMS_RB_BLACK },
0365   { 6, NULL, TN( 2 ), TN( 8 ), RTEMS_RB_BLACK },
0366   { 7, TN( 8 ), NULL, NULL, RTEMS_RB_RED },
0367   { 8, TN( 6 ), TN( 7 ), TN( 9 ), RTEMS_RB_BLACK },
0368   { 9, TN( 8 ), NULL, NULL, RTEMS_RB_RED }
0369 };
0370 
0371 static const TestNodeDescription random_ops_tree_multiple_11[] = {
0372   { 1, TN( 6 ), NULL, NULL, RTEMS_RB_BLACK },
0373   { 3, NULL, TN( 2 ), TN( 8 ), RTEMS_RB_BLACK },
0374   { 3, TN( 8 ), NULL, NULL, RTEMS_RB_RED },
0375   { 4, TN( 6 ), TN( 7 ), TN( 9 ), RTEMS_RB_BLACK },
0376   { 4, TN( 8 ), NULL, NULL, RTEMS_RB_RED }
0377 };
0378 
0379 static const TestNodeDescription random_ops_tree_unique_12[] = {
0380   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0381   { 1, TN( 3 ), TN( 0 ), TN( 2 ), RTEMS_RB_BLACK },
0382   { 2, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0383   { 3, TN( 5 ), TN( 1 ), TN( 4 ), RTEMS_RB_RED },
0384   { 4, TN( 3 ), NULL, NULL, RTEMS_RB_BLACK },
0385   { 5, NULL, TN( 3 ), TN( 9 ), RTEMS_RB_BLACK },
0386   { 9, TN( 5 ), NULL, TN( 11 ), RTEMS_RB_BLACK },
0387   { 11, TN( 9 ), NULL, NULL, RTEMS_RB_RED }
0388 };
0389 
0390 static const TestNodeDescription random_ops_tree_multiple_12[] = {
0391   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_BLACK },
0392   { 0, TN( 5 ), TN( 0 ), TN( 3 ), RTEMS_RB_RED },
0393   { 1, TN( 1 ), NULL, TN( 2 ), RTEMS_RB_BLACK },
0394   { 1, TN( 3 ), NULL, NULL, RTEMS_RB_RED },
0395   { 2, NULL, TN( 1 ), TN( 9 ), RTEMS_RB_BLACK },
0396   { 2, TN( 9 ), NULL, NULL, RTEMS_RB_BLACK },
0397   { 4, TN( 5 ), TN( 4 ), TN( 11 ), RTEMS_RB_RED },
0398   { 5, TN( 9 ), NULL, NULL, RTEMS_RB_BLACK }
0399 };
0400 
0401 static const TestNodeDescription random_ops_tree_unique_13[] = {
0402   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0403   { 1, TN( 3 ), TN( 0 ), NULL, RTEMS_RB_BLACK },
0404   { 3, TN( 8 ), TN( 1 ), TN( 5 ), RTEMS_RB_RED },
0405   { 4, TN( 5 ), NULL, NULL, RTEMS_RB_RED },
0406   { 5, TN( 3 ), TN( 4 ), TN( 6 ), RTEMS_RB_BLACK },
0407   { 6, TN( 5 ), NULL, NULL, RTEMS_RB_RED },
0408   { 8, NULL, TN( 3 ), TN( 11 ), RTEMS_RB_BLACK },
0409   { 10, TN( 11 ), NULL, NULL, RTEMS_RB_RED },
0410   { 11, TN( 8 ), TN( 10 ), NULL, RTEMS_RB_BLACK }
0411 };
0412 
0413 static const TestNodeDescription random_ops_tree_multiple_13[] = {
0414   { 0, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0415   { 0, TN( 3 ), TN( 1 ), NULL, RTEMS_RB_BLACK },
0416   { 1, TN( 6 ), TN( 0 ), TN( 4 ), RTEMS_RB_RED },
0417   { 2, TN( 3 ), NULL, TN( 5 ), RTEMS_RB_BLACK },
0418   { 2, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0419   { 3, NULL, TN( 3 ), TN( 11 ), RTEMS_RB_BLACK },
0420   { 4, TN( 11 ), NULL, NULL, RTEMS_RB_RED },
0421   { 5, TN( 6 ), TN( 8 ), TN( 10 ), RTEMS_RB_BLACK },
0422   { 5, TN( 11 ), NULL, NULL, RTEMS_RB_RED }
0423 };
0424 
0425 static const TestNodeDescription random_ops_tree_unique_14[] = {
0426   { 3, TN( 5 ), NULL, NULL, RTEMS_RB_RED },
0427   { 5, TN( 6 ), TN( 3 ), NULL, RTEMS_RB_BLACK },
0428   { 6, NULL, TN( 5 ), TN( 12 ), RTEMS_RB_BLACK },
0429   { 8, TN( 12 ), NULL, NULL, RTEMS_RB_BLACK },
0430   { 12, TN( 6 ), TN( 8 ), TN( 13 ), RTEMS_RB_RED },
0431   { 13, TN( 12 ), NULL, NULL, RTEMS_RB_BLACK }
0432 };
0433 
0434 static const TestNodeDescription random_ops_tree_multiple_14[] = {
0435   { 1, TN( 5 ), NULL, NULL, RTEMS_RB_RED },
0436   { 2, TN( 6 ), TN( 3 ), NULL, RTEMS_RB_BLACK },
0437   { 3, NULL, TN( 5 ), TN( 13 ), RTEMS_RB_BLACK },
0438   { 4, TN( 13 ), NULL, NULL, RTEMS_RB_BLACK },
0439   { 6, TN( 6 ), TN( 8 ), TN( 12 ), RTEMS_RB_RED },
0440   { 6, TN( 13 ), NULL, NULL, RTEMS_RB_BLACK }
0441 };
0442 
0443 static const TestNodeDescription random_ops_tree_unique_15[] = {
0444   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0445   { 2, TN( 8 ), TN( 0 ), TN( 7 ), RTEMS_RB_BLACK },
0446   { 7, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0447   { 8, NULL, TN( 2 ), TN( 12 ), RTEMS_RB_BLACK },
0448   { 9, TN( 12 ), NULL, TN( 10 ), RTEMS_RB_BLACK },
0449   { 10, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0450   { 12, TN( 8 ), TN( 9 ), TN( 13 ), RTEMS_RB_RED },
0451   { 13, TN( 12 ), NULL, TN( 14 ), RTEMS_RB_BLACK },
0452   { 14, TN( 13 ), NULL, NULL, RTEMS_RB_RED }
0453 };
0454 
0455 static const TestNodeDescription random_ops_tree_multiple_15[] = {
0456   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0457   { 1, TN( 9 ), TN( 0 ), TN( 7 ), RTEMS_RB_BLACK },
0458   { 3, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0459   { 4, NULL, TN( 2 ), TN( 10 ), RTEMS_RB_BLACK },
0460   { 4, TN( 10 ), NULL, NULL, RTEMS_RB_BLACK },
0461   { 5, TN( 9 ), TN( 8 ), TN( 12 ), RTEMS_RB_RED },
0462   { 6, TN( 12 ), NULL, NULL, RTEMS_RB_RED },
0463   { 6, TN( 10 ), TN( 13 ), TN( 14 ), RTEMS_RB_BLACK },
0464   { 7, TN( 12 ), NULL, NULL, RTEMS_RB_RED }
0465 };
0466 
0467 static const TestNodeDescription random_ops_tree_unique_16[] = {
0468   { 0, TN( 5 ), NULL, TN( 3 ), RTEMS_RB_BLACK },
0469   { 3, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0470   { 5, TN( 10 ), TN( 0 ), TN( 7 ), RTEMS_RB_RED },
0471   { 7, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0472   { 10, NULL, TN( 5 ), TN( 12 ), RTEMS_RB_BLACK },
0473   { 12, TN( 10 ), NULL, NULL, RTEMS_RB_BLACK }
0474 };
0475 
0476 static const TestNodeDescription random_ops_tree_multiple_16[] = {
0477   { 0, TN( 5 ), NULL, TN( 3 ), RTEMS_RB_BLACK },
0478   { 1, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0479   { 2, TN( 10 ), TN( 0 ), TN( 7 ), RTEMS_RB_RED },
0480   { 3, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0481   { 5, NULL, TN( 5 ), TN( 12 ), RTEMS_RB_BLACK },
0482   { 6, TN( 10 ), NULL, NULL, RTEMS_RB_BLACK }
0483 };
0484 
0485 static const TestNodeDescription random_ops_tree_unique_17[] = {
0486   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0487   { 1, TN( 3 ), TN( 0 ), NULL, RTEMS_RB_BLACK },
0488   { 3, TN( 7 ), TN( 1 ), TN( 5 ), RTEMS_RB_RED },
0489   { 4, TN( 5 ), NULL, NULL, RTEMS_RB_RED },
0490   { 5, TN( 3 ), TN( 4 ), NULL, RTEMS_RB_BLACK },
0491   { 7, NULL, TN( 3 ), TN( 9 ), RTEMS_RB_BLACK },
0492   { 8, TN( 9 ), NULL, NULL, RTEMS_RB_BLACK },
0493   { 9, TN( 7 ), TN( 8 ), TN( 16 ), RTEMS_RB_RED },
0494   { 16, TN( 9 ), NULL, NULL, RTEMS_RB_BLACK }
0495 };
0496 
0497 static const TestNodeDescription random_ops_tree_multiple_17[] = {
0498   { 0, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0499   { 0, TN( 3 ), TN( 1 ), NULL, RTEMS_RB_BLACK },
0500   { 1, TN( 7 ), TN( 0 ), TN( 5 ), RTEMS_RB_RED },
0501   { 2, TN( 3 ), NULL, TN( 4 ), RTEMS_RB_BLACK },
0502   { 2, TN( 5 ), NULL, NULL, RTEMS_RB_RED },
0503   { 3, NULL, TN( 3 ), TN( 8 ), RTEMS_RB_BLACK },
0504   { 4, TN( 8 ), NULL, NULL, RTEMS_RB_BLACK },
0505   { 4, TN( 7 ), TN( 9 ), TN( 16 ), RTEMS_RB_RED },
0506   { 8, TN( 8 ), NULL, NULL, RTEMS_RB_BLACK }
0507 };
0508 
0509 static const TestNodeDescription random_ops_tree_unique_18[] = {
0510   { 0, TN( 2 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0511   { 1, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0512   { 2, TN( 4 ), TN( 0 ), TN( 3 ), RTEMS_RB_BLACK },
0513   { 3, TN( 2 ), NULL, NULL, RTEMS_RB_BLACK },
0514   { 4, NULL, TN( 2 ), TN( 12 ), RTEMS_RB_BLACK },
0515   { 5, TN( 6 ), NULL, NULL, RTEMS_RB_RED },
0516   { 6, TN( 8 ), TN( 5 ), TN( 7 ), RTEMS_RB_BLACK },
0517   { 7, TN( 6 ), NULL, NULL, RTEMS_RB_RED },
0518   { 8, TN( 12 ), TN( 6 ), TN( 10 ), RTEMS_RB_RED },
0519   { 9, TN( 10 ), NULL, NULL, RTEMS_RB_RED },
0520   { 10, TN( 8 ), TN( 9 ), NULL, RTEMS_RB_BLACK },
0521   { 12, TN( 4 ), TN( 8 ), TN( 17 ), RTEMS_RB_BLACK },
0522   { 14, TN( 17 ), NULL, NULL, RTEMS_RB_RED },
0523   { 17, TN( 12 ), TN( 14 ), NULL, RTEMS_RB_BLACK }
0524 };
0525 
0526 static const TestNodeDescription random_ops_tree_multiple_18[] = {
0527   { 0, TN( 3 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0528   { 0, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0529   { 1, TN( 4 ), TN( 0 ), TN( 2 ), RTEMS_RB_BLACK },
0530   { 1, TN( 3 ), NULL, NULL, RTEMS_RB_BLACK },
0531   { 2, NULL, TN( 3 ), TN( 12 ), RTEMS_RB_BLACK },
0532   { 2, TN( 6 ), NULL, NULL, RTEMS_RB_RED },
0533   { 3, TN( 8 ), TN( 5 ), TN( 7 ), RTEMS_RB_BLACK },
0534   { 3, TN( 6 ), NULL, NULL, RTEMS_RB_RED },
0535   { 4, TN( 12 ), TN( 6 ), TN( 10 ), RTEMS_RB_RED },
0536   { 4, TN( 10 ), NULL, NULL, RTEMS_RB_RED },
0537   { 5, TN( 8 ), TN( 9 ), NULL, RTEMS_RB_BLACK },
0538   { 6, TN( 4 ), TN( 8 ), TN( 14 ), RTEMS_RB_BLACK },
0539   { 7, TN( 12 ), NULL, TN( 17 ), RTEMS_RB_BLACK },
0540   { 8, TN( 14 ), NULL, NULL, RTEMS_RB_RED }
0541 };
0542 
0543 static const TestNodeDescription random_ops_tree_unique_19[] = {
0544   { 1, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0545   { 2, TN( 6 ), TN( 1 ), NULL, RTEMS_RB_BLACK },
0546   { 6, TN( 11 ), TN( 2 ), TN( 8 ), RTEMS_RB_BLACK },
0547   { 8, TN( 6 ), NULL, TN( 9 ), RTEMS_RB_BLACK },
0548   { 9, TN( 8 ), NULL, NULL, RTEMS_RB_RED },
0549   { 11, NULL, TN( 6 ), TN( 14 ), RTEMS_RB_BLACK },
0550   { 12, TN( 14 ), NULL, NULL, RTEMS_RB_BLACK },
0551   { 14, TN( 11 ), TN( 12 ), TN( 16 ), RTEMS_RB_BLACK },
0552   { 16, TN( 14 ), NULL, NULL, RTEMS_RB_BLACK }
0553 };
0554 
0555 static const TestNodeDescription random_ops_tree_multiple_19[] = {
0556   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0557   { 1, TN( 6 ), TN( 1 ), NULL, RTEMS_RB_BLACK },
0558   { 3, TN( 11 ), TN( 2 ), TN( 9 ), RTEMS_RB_BLACK },
0559   { 4, TN( 6 ), NULL, TN( 8 ), RTEMS_RB_BLACK },
0560   { 4, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0561   { 5, NULL, TN( 6 ), TN( 14 ), RTEMS_RB_BLACK },
0562   { 6, TN( 14 ), NULL, NULL, RTEMS_RB_BLACK },
0563   { 7, TN( 11 ), TN( 12 ), TN( 16 ), RTEMS_RB_BLACK },
0564   { 8, TN( 14 ), NULL, NULL, RTEMS_RB_BLACK }
0565 };
0566 
0567 static const TestNodeDescription random_ops_tree_unique_20[] = {
0568   { 0, TN( 3 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0569   { 1, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0570   { 3, TN( 9 ), TN( 0 ), TN( 7 ), RTEMS_RB_BLACK },
0571   { 4, TN( 7 ), NULL, NULL, RTEMS_RB_RED },
0572   { 7, TN( 3 ), TN( 4 ), NULL, RTEMS_RB_BLACK },
0573   { 9, NULL, TN( 3 ), TN( 12 ), RTEMS_RB_BLACK },
0574   { 10, TN( 12 ), NULL, NULL, RTEMS_RB_BLACK },
0575   { 12, TN( 9 ), TN( 10 ), TN( 17 ), RTEMS_RB_BLACK },
0576   { 14, TN( 17 ), NULL, NULL, RTEMS_RB_BLACK },
0577   { 17, TN( 12 ), TN( 14 ), TN( 18 ), RTEMS_RB_RED },
0578   { 18, TN( 17 ), NULL, TN( 19 ), RTEMS_RB_BLACK },
0579   { 19, TN( 18 ), NULL, NULL, RTEMS_RB_RED }
0580 };
0581 
0582 static const TestNodeDescription random_ops_tree_multiple_20[] = {
0583   { 0, TN( 3 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0584   { 0, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0585   { 1, TN( 9 ), TN( 0 ), TN( 7 ), RTEMS_RB_BLACK },
0586   { 2, TN( 7 ), NULL, NULL, RTEMS_RB_RED },
0587   { 3, TN( 3 ), TN( 4 ), NULL, RTEMS_RB_BLACK },
0588   { 4, NULL, TN( 3 ), TN( 14 ), RTEMS_RB_BLACK },
0589   { 5, TN( 14 ), NULL, TN( 12 ), RTEMS_RB_BLACK },
0590   { 6, TN( 10 ), NULL, NULL, RTEMS_RB_RED },
0591   { 7, TN( 9 ), TN( 10 ), TN( 18 ), RTEMS_RB_BLACK },
0592   { 8, TN( 18 ), NULL, NULL, RTEMS_RB_RED },
0593   { 9, TN( 14 ), TN( 17 ), TN( 19 ), RTEMS_RB_BLACK },
0594   { 9, TN( 18 ), NULL, NULL, RTEMS_RB_RED }
0595 };
0596 
0597 static const TestNodeDescription random_ops_tree_unique_21[] = {
0598   { 0, TN( 3 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0599   { 1, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0600   { 3, TN( 11 ), TN( 0 ), TN( 5 ), RTEMS_RB_BLACK },
0601   { 4, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0602   { 5, TN( 3 ), TN( 4 ), TN( 8 ), RTEMS_RB_RED },
0603   { 8, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0604   { 11, NULL, TN( 3 ), TN( 15 ), RTEMS_RB_BLACK },
0605   { 13, TN( 15 ), NULL, NULL, RTEMS_RB_BLACK },
0606   { 15, TN( 11 ), TN( 13 ), TN( 17 ), RTEMS_RB_BLACK },
0607   { 16, TN( 17 ), NULL, NULL, RTEMS_RB_RED },
0608   { 17, TN( 15 ), TN( 16 ), NULL, RTEMS_RB_BLACK }
0609 };
0610 
0611 static const TestNodeDescription random_ops_tree_multiple_21[] = {
0612   { 0, TN( 3 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0613   { 0, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0614   { 1, TN( 8 ), TN( 0 ), TN( 4 ), RTEMS_RB_BLACK },
0615   { 2, TN( 3 ), NULL, TN( 5 ), RTEMS_RB_BLACK },
0616   { 2, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0617   { 4, NULL, TN( 3 ), TN( 13 ), RTEMS_RB_BLACK },
0618   { 5, TN( 13 ), NULL, NULL, RTEMS_RB_BLACK },
0619   { 6, TN( 8 ), TN( 11 ), TN( 17 ), RTEMS_RB_BLACK },
0620   { 7, TN( 17 ), NULL, NULL, RTEMS_RB_BLACK },
0621   { 8, TN( 13 ), TN( 15 ), TN( 16 ), RTEMS_RB_RED },
0622   { 8, TN( 17 ), NULL, NULL, RTEMS_RB_BLACK }
0623 };
0624 
0625 static const TestNodeDescription random_ops_tree_unique_22[] = {
0626   { 1, TN( 3 ), NULL, TN( 2 ), RTEMS_RB_BLACK },
0627   { 2, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0628   { 3, TN( 8 ), TN( 1 ), TN( 7 ), RTEMS_RB_BLACK },
0629   { 4, TN( 7 ), NULL, NULL, RTEMS_RB_RED },
0630   { 7, TN( 3 ), TN( 4 ), NULL, RTEMS_RB_BLACK },
0631   { 8, NULL, TN( 3 ), TN( 14 ), RTEMS_RB_BLACK },
0632   { 10, TN( 11 ), NULL, NULL, RTEMS_RB_RED },
0633   { 11, TN( 14 ), TN( 10 ), NULL, RTEMS_RB_BLACK },
0634   { 14, TN( 8 ), TN( 11 ), TN( 18 ), RTEMS_RB_BLACK },
0635   { 15, TN( 18 ), NULL, NULL, RTEMS_RB_BLACK },
0636   { 18, TN( 14 ), TN( 15 ), TN( 21 ), RTEMS_RB_RED },
0637   { 21, TN( 18 ), NULL, NULL, RTEMS_RB_BLACK }
0638 };
0639 
0640 static const TestNodeDescription random_ops_tree_multiple_22[] = {
0641   { 0, TN( 3 ), NULL, NULL, RTEMS_RB_BLACK },
0642   { 1, TN( 8 ), TN( 1 ), TN( 4 ), RTEMS_RB_BLACK },
0643   { 1, TN( 4 ), NULL, NULL, RTEMS_RB_BLACK },
0644   { 2, TN( 3 ), TN( 2 ), TN( 7 ), RTEMS_RB_RED },
0645   { 3, TN( 4 ), NULL, NULL, RTEMS_RB_BLACK },
0646   { 4, NULL, TN( 3 ), TN( 14 ), RTEMS_RB_BLACK },
0647   { 5, TN( 14 ), NULL, TN( 10 ), RTEMS_RB_BLACK },
0648   { 5, TN( 11 ), NULL, NULL, RTEMS_RB_RED },
0649   { 7, TN( 8 ), TN( 11 ), TN( 18 ), RTEMS_RB_BLACK },
0650   { 7, TN( 18 ), NULL, NULL, RTEMS_RB_BLACK },
0651   { 9, TN( 14 ), TN( 15 ), TN( 21 ), RTEMS_RB_RED },
0652   { 10, TN( 18 ), NULL, NULL, RTEMS_RB_BLACK }
0653 };
0654 
0655 static const TestNodeDescription random_ops_tree_unique_23[] = {
0656   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0657   { 2, TN( 8 ), TN( 0 ), TN( 7 ), RTEMS_RB_BLACK },
0658   { 7, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0659   { 8, TN( 12 ), TN( 2 ), TN( 11 ), RTEMS_RB_BLACK },
0660   { 11, TN( 8 ), NULL, NULL, RTEMS_RB_BLACK },
0661   { 12, NULL, TN( 8 ), TN( 17 ), RTEMS_RB_BLACK },
0662   { 13, TN( 15 ), NULL, TN( 14 ), RTEMS_RB_BLACK },
0663   { 14, TN( 13 ), NULL, NULL, RTEMS_RB_RED },
0664   { 15, TN( 17 ), TN( 13 ), TN( 16 ), RTEMS_RB_RED },
0665   { 16, TN( 15 ), NULL, NULL, RTEMS_RB_BLACK },
0666   { 17, TN( 12 ), TN( 15 ), TN( 20 ), RTEMS_RB_BLACK },
0667   { 20, TN( 17 ), NULL, TN( 21 ), RTEMS_RB_BLACK },
0668   { 21, TN( 20 ), NULL, NULL, RTEMS_RB_RED }
0669 };
0670 
0671 static const TestNodeDescription random_ops_tree_multiple_23[] = {
0672   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0673   { 1, TN( 8 ), TN( 0 ), TN( 7 ), RTEMS_RB_BLACK },
0674   { 3, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0675   { 4, TN( 12 ), TN( 2 ), TN( 11 ), RTEMS_RB_BLACK },
0676   { 5, TN( 8 ), NULL, NULL, RTEMS_RB_BLACK },
0677   { 6, NULL, TN( 8 ), TN( 17 ), RTEMS_RB_BLACK },
0678   { 6, TN( 15 ), NULL, NULL, RTEMS_RB_BLACK },
0679   { 7, TN( 17 ), TN( 13 ), TN( 16 ), RTEMS_RB_RED },
0680   { 7, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0681   { 8, TN( 15 ), TN( 14 ), NULL, RTEMS_RB_BLACK },
0682   { 8, TN( 12 ), TN( 15 ), TN( 20 ), RTEMS_RB_BLACK },
0683   { 10, TN( 17 ), NULL, TN( 21 ), RTEMS_RB_BLACK },
0684   { 10, TN( 20 ), NULL, NULL, RTEMS_RB_RED }
0685 };
0686 
0687 static const TestNodeDescription random_ops_tree_unique_24[] = {
0688   { 4, TN( 6 ), NULL, TN( 5 ), RTEMS_RB_BLACK },
0689   { 5, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0690   { 6, TN( 14 ), TN( 4 ), TN( 10 ), RTEMS_RB_BLACK },
0691   { 8, TN( 10 ), NULL, NULL, RTEMS_RB_RED },
0692   { 10, TN( 6 ), TN( 8 ), NULL, RTEMS_RB_BLACK },
0693   { 14, NULL, TN( 6 ), TN( 20 ), RTEMS_RB_BLACK },
0694   { 15, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0695   { 16, TN( 20 ), TN( 15 ), NULL, RTEMS_RB_BLACK },
0696   { 20, TN( 14 ), TN( 16 ), TN( 22 ), RTEMS_RB_BLACK },
0697   { 22, TN( 20 ), NULL, NULL, RTEMS_RB_BLACK }
0698 };
0699 
0700 static const TestNodeDescription random_ops_tree_multiple_24[] = {
0701   { 2, TN( 6 ), NULL, TN( 5 ), RTEMS_RB_BLACK },
0702   { 2, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0703   { 3, TN( 14 ), TN( 4 ), TN( 10 ), RTEMS_RB_BLACK },
0704   { 4, TN( 10 ), NULL, NULL, RTEMS_RB_RED },
0705   { 5, TN( 6 ), TN( 8 ), NULL, RTEMS_RB_BLACK },
0706   { 7, NULL, TN( 6 ), TN( 20 ), RTEMS_RB_BLACK },
0707   { 7, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0708   { 8, TN( 20 ), TN( 15 ), NULL, RTEMS_RB_BLACK },
0709   { 10, TN( 14 ), TN( 16 ), TN( 22 ), RTEMS_RB_BLACK },
0710   { 11, TN( 20 ), NULL, NULL, RTEMS_RB_BLACK }
0711 };
0712 
0713 static const TestNodeDescription random_ops_tree_unique_25[] = {
0714   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0715   { 1, TN( 3 ), TN( 0 ), NULL, RTEMS_RB_BLACK },
0716   { 3, TN( 13 ), TN( 1 ), TN( 5 ), RTEMS_RB_BLACK },
0717   { 4, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0718   { 5, TN( 3 ), TN( 4 ), TN( 6 ), RTEMS_RB_RED },
0719   { 6, TN( 5 ), NULL, TN( 9 ), RTEMS_RB_BLACK },
0720   { 9, TN( 6 ), NULL, NULL, RTEMS_RB_RED },
0721   { 13, NULL, TN( 3 ), TN( 19 ), RTEMS_RB_BLACK },
0722   { 14, TN( 15 ), NULL, NULL, RTEMS_RB_RED },
0723   { 15, TN( 16 ), TN( 14 ), NULL, RTEMS_RB_BLACK },
0724   { 16, TN( 19 ), TN( 15 ), TN( 17 ), RTEMS_RB_RED },
0725   { 17, TN( 16 ), NULL, NULL, RTEMS_RB_BLACK },
0726   { 19, TN( 13 ), TN( 16 ), TN( 23 ), RTEMS_RB_BLACK },
0727   { 23, TN( 19 ), NULL, TN( 24 ), RTEMS_RB_BLACK },
0728   { 24, TN( 23 ), NULL, NULL, RTEMS_RB_RED }
0729 };
0730 
0731 static const TestNodeDescription random_ops_tree_multiple_25[] = {
0732   { 0, TN( 3 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0733   { 0, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0734   { 1, TN( 13 ), TN( 0 ), TN( 4 ), RTEMS_RB_BLACK },
0735   { 2, TN( 4 ), NULL, NULL, RTEMS_RB_BLACK },
0736   { 2, TN( 3 ), TN( 5 ), TN( 6 ), RTEMS_RB_RED },
0737   { 3, TN( 4 ), NULL, TN( 9 ), RTEMS_RB_BLACK },
0738   { 4, TN( 6 ), NULL, NULL, RTEMS_RB_RED },
0739   { 6, NULL, TN( 3 ), TN( 19 ), RTEMS_RB_BLACK },
0740   { 7, TN( 17 ), NULL, TN( 14 ), RTEMS_RB_BLACK },
0741   { 7, TN( 15 ), NULL, NULL, RTEMS_RB_RED },
0742   { 8, TN( 19 ), TN( 15 ), TN( 16 ), RTEMS_RB_RED },
0743   { 8, TN( 17 ), NULL, NULL, RTEMS_RB_BLACK },
0744   { 9, TN( 13 ), TN( 17 ), TN( 23 ), RTEMS_RB_BLACK },
0745   { 11, TN( 19 ), NULL, TN( 24 ), RTEMS_RB_BLACK },
0746   { 12, TN( 23 ), NULL, NULL, RTEMS_RB_RED }
0747 };
0748 
0749 static const TestNodeDescription random_ops_tree_unique_26[] = {
0750   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0751   { 1, TN( 3 ), TN( 0 ), NULL, RTEMS_RB_BLACK },
0752   { 3, TN( 11 ), TN( 1 ), TN( 9 ), RTEMS_RB_BLACK },
0753   { 6, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0754   { 9, TN( 3 ), TN( 6 ), TN( 10 ), RTEMS_RB_BLACK },
0755   { 10, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0756   { 11, NULL, TN( 3 ), TN( 14 ), RTEMS_RB_BLACK },
0757   { 12, TN( 14 ), NULL, TN( 13 ), RTEMS_RB_BLACK },
0758   { 13, TN( 12 ), NULL, NULL, RTEMS_RB_RED },
0759   { 14, TN( 11 ), TN( 12 ), TN( 20 ), RTEMS_RB_BLACK },
0760   { 18, TN( 20 ), NULL, NULL, RTEMS_RB_BLACK },
0761   { 20, TN( 14 ), TN( 18 ), TN( 23 ), RTEMS_RB_RED },
0762   { 21, TN( 23 ), NULL, NULL, RTEMS_RB_RED },
0763   { 23, TN( 20 ), TN( 21 ), NULL, RTEMS_RB_BLACK }
0764 };
0765 
0766 static const TestNodeDescription random_ops_tree_multiple_26[] = {
0767   { 0, TN( 3 ), NULL, TN( 0 ), RTEMS_RB_BLACK },
0768   { 0, TN( 1 ), NULL, NULL, RTEMS_RB_RED },
0769   { 1, TN( 9 ), TN( 1 ), TN( 6 ), RTEMS_RB_BLACK },
0770   { 3, TN( 3 ), NULL, NULL, RTEMS_RB_BLACK },
0771   { 4, NULL, TN( 3 ), TN( 14 ), RTEMS_RB_BLACK },
0772   { 5, TN( 12 ), NULL, TN( 10 ), RTEMS_RB_BLACK },
0773   { 5, TN( 11 ), NULL, NULL, RTEMS_RB_RED },
0774   { 6, TN( 14 ), TN( 11 ), TN( 13 ), RTEMS_RB_RED },
0775   { 6, TN( 12 ), NULL, NULL, RTEMS_RB_BLACK },
0776   { 7, TN( 9 ), TN( 12 ), TN( 20 ), RTEMS_RB_BLACK },
0777   { 9, TN( 20 ), NULL, NULL, RTEMS_RB_BLACK },
0778   { 10, TN( 14 ), TN( 18 ), TN( 23 ), RTEMS_RB_RED },
0779   { 10, TN( 23 ), NULL, NULL, RTEMS_RB_RED },
0780   { 11, TN( 20 ), TN( 21 ), NULL, RTEMS_RB_BLACK }
0781 };
0782 
0783 static const TestNodeDescription random_ops_tree_unique_27[] = {
0784   { 3, TN( 8 ), NULL, NULL, RTEMS_RB_BLACK },
0785   { 8, TN( 19 ), TN( 3 ), TN( 17 ), RTEMS_RB_BLACK },
0786   { 12, TN( 17 ), NULL, NULL, RTEMS_RB_RED },
0787   { 17, TN( 8 ), TN( 12 ), NULL, RTEMS_RB_BLACK },
0788   { 19, NULL, TN( 8 ), TN( 24 ), RTEMS_RB_BLACK },
0789   { 20, TN( 21 ), NULL, NULL, RTEMS_RB_RED },
0790   { 21, TN( 24 ), TN( 20 ), TN( 23 ), RTEMS_RB_BLACK },
0791   { 23, TN( 21 ), NULL, NULL, RTEMS_RB_RED },
0792   { 24, TN( 19 ), TN( 21 ), TN( 25 ), RTEMS_RB_BLACK },
0793   { 25, TN( 24 ), NULL, TN( 26 ), RTEMS_RB_BLACK },
0794   { 26, TN( 25 ), NULL, NULL, RTEMS_RB_RED }
0795 };
0796 
0797 static const TestNodeDescription random_ops_tree_multiple_27[] = {
0798   { 1, TN( 8 ), NULL, NULL, RTEMS_RB_BLACK },
0799   { 4, TN( 19 ), TN( 3 ), TN( 17 ), RTEMS_RB_BLACK },
0800   { 6, TN( 17 ), NULL, NULL, RTEMS_RB_RED },
0801   { 8, TN( 8 ), TN( 12 ), NULL, RTEMS_RB_BLACK },
0802   { 9, NULL, TN( 8 ), TN( 25 ), RTEMS_RB_BLACK },
0803   { 10, TN( 21 ), NULL, NULL, RTEMS_RB_RED },
0804   { 10, TN( 25 ), TN( 20 ), TN( 23 ), RTEMS_RB_BLACK },
0805   { 11, TN( 21 ), NULL, NULL, RTEMS_RB_RED },
0806   { 12, TN( 19 ), TN( 21 ), TN( 24 ), RTEMS_RB_BLACK },
0807   { 12, TN( 25 ), NULL, TN( 26 ), RTEMS_RB_BLACK },
0808   { 13, TN( 24 ), NULL, NULL, RTEMS_RB_RED }
0809 };
0810 
0811 static const TestNodeDescription random_ops_tree_unique_28[] = {
0812   { 0, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0813   { 5, TN( 13 ), TN( 0 ), TN( 7 ), RTEMS_RB_RED },
0814   { 7, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0815   { 13, NULL, TN( 5 ), TN( 17 ), RTEMS_RB_BLACK },
0816   { 15, TN( 17 ), NULL, NULL, RTEMS_RB_BLACK },
0817   { 17, TN( 13 ), TN( 15 ), TN( 26 ), RTEMS_RB_RED },
0818   { 21, TN( 26 ), NULL, NULL, RTEMS_RB_RED },
0819   { 26, TN( 17 ), TN( 21 ), NULL, RTEMS_RB_BLACK }
0820 };
0821 
0822 static const TestNodeDescription random_ops_tree_multiple_28[] = {
0823   { 0, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0824   { 2, TN( 13 ), TN( 0 ), TN( 7 ), RTEMS_RB_RED },
0825   { 3, TN( 5 ), NULL, NULL, RTEMS_RB_BLACK },
0826   { 6, NULL, TN( 5 ), TN( 17 ), RTEMS_RB_BLACK },
0827   { 7, TN( 17 ), NULL, NULL, RTEMS_RB_BLACK },
0828   { 8, TN( 13 ), TN( 15 ), TN( 26 ), RTEMS_RB_RED },
0829   { 10, TN( 26 ), NULL, NULL, RTEMS_RB_RED },
0830   { 13, TN( 17 ), TN( 21 ), NULL, RTEMS_RB_BLACK }
0831 };
0832 
0833 static const TestNodeDescription random_ops_tree_unique_29[] = {
0834   { 0, TN( 3 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0835   { 1, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0836   { 3, TN( 12 ), TN( 0 ), TN( 6 ), RTEMS_RB_BLACK },
0837   { 4, TN( 6 ), NULL, NULL, RTEMS_RB_BLACK },
0838   { 6, TN( 3 ), TN( 4 ), TN( 8 ), RTEMS_RB_RED },
0839   { 7, TN( 8 ), NULL, NULL, RTEMS_RB_RED },
0840   { 8, TN( 6 ), TN( 7 ), TN( 11 ), RTEMS_RB_BLACK },
0841   { 11, TN( 8 ), NULL, NULL, RTEMS_RB_RED },
0842   { 12, NULL, TN( 3 ), TN( 17 ), RTEMS_RB_BLACK },
0843   { 13, TN( 17 ), NULL, TN( 14 ), RTEMS_RB_BLACK },
0844   { 14, TN( 13 ), NULL, NULL, RTEMS_RB_RED },
0845   { 17, TN( 12 ), TN( 13 ), TN( 25 ), RTEMS_RB_BLACK },
0846   { 22, TN( 25 ), NULL, NULL, RTEMS_RB_RED },
0847   { 25, TN( 17 ), TN( 22 ), TN( 27 ), RTEMS_RB_BLACK },
0848   { 27, TN( 25 ), NULL, NULL, RTEMS_RB_RED }
0849 };
0850 
0851 static const TestNodeDescription random_ops_tree_multiple_29[] = {
0852   { 0, TN( 3 ), NULL, TN( 1 ), RTEMS_RB_BLACK },
0853   { 0, TN( 0 ), NULL, NULL, RTEMS_RB_RED },
0854   { 1, TN( 11 ), TN( 0 ), TN( 6 ), RTEMS_RB_BLACK },
0855   { 2, TN( 6 ), NULL, NULL, RTEMS_RB_BLACK },
0856   { 3, TN( 3 ), TN( 4 ), TN( 7 ), RTEMS_RB_RED },
0857   { 3, TN( 6 ), NULL, TN( 8 ), RTEMS_RB_BLACK },
0858   { 4, TN( 7 ), NULL, NULL, RTEMS_RB_RED },
0859   { 5, NULL, TN( 3 ), TN( 22 ), RTEMS_RB_BLACK },
0860   { 6, TN( 12 ), NULL, NULL, RTEMS_RB_BLACK },
0861   { 6, TN( 22 ), TN( 13 ), TN( 17 ), RTEMS_RB_RED },
0862   { 7, TN( 17 ), NULL, NULL, RTEMS_RB_RED },
0863   { 8, TN( 12 ), TN( 14 ), NULL, RTEMS_RB_BLACK },
0864   { 11, TN( 11 ), TN( 12 ), TN( 25 ), RTEMS_RB_BLACK },
0865   { 12, TN( 22 ), NULL, TN( 27 ), RTEMS_RB_BLACK },
0866   { 13, TN( 25 ), NULL, NULL, RTEMS_RB_RED }
0867 };
0868 
0869 static const TestNodeDescription random_ops_tree_unique_30[] = {
0870   { 0, TN( 4 ), NULL, NULL, RTEMS_RB_RED },
0871   { 4, TN( 6 ), TN( 0 ), NULL, RTEMS_RB_BLACK },
0872   { 6, TN( 13 ), TN( 4 ), TN( 9 ), RTEMS_RB_RED },
0873   { 8, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0874   { 9, TN( 6 ), TN( 8 ), TN( 12 ), RTEMS_RB_BLACK },
0875   { 12, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0876   { 13, NULL, TN( 6 ), TN( 18 ), RTEMS_RB_BLACK },
0877   { 14, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0878   { 16, TN( 18 ), TN( 14 ), TN( 17 ), RTEMS_RB_BLACK },
0879   { 17, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0880   { 18, TN( 13 ), TN( 16 ), TN( 27 ), RTEMS_RB_RED },
0881   { 20, TN( 27 ), NULL, NULL, RTEMS_RB_RED },
0882   { 27, TN( 18 ), TN( 20 ), TN( 28 ), RTEMS_RB_BLACK },
0883   { 28, TN( 27 ), NULL, NULL, RTEMS_RB_RED }
0884 };
0885 
0886 static const TestNodeDescription random_ops_tree_multiple_30[] = {
0887   { 0, TN( 4 ), NULL, NULL, RTEMS_RB_BLACK },
0888   { 2, TN( 13 ), TN( 0 ), TN( 9 ), RTEMS_RB_RED },
0889   { 3, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0890   { 4, TN( 4 ), TN( 6 ), TN( 8 ), RTEMS_RB_BLACK },
0891   { 4, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0892   { 6, TN( 14 ), TN( 4 ), TN( 12 ), RTEMS_RB_BLACK },
0893   { 6, TN( 13 ), NULL, NULL, RTEMS_RB_BLACK },
0894   { 7, NULL, TN( 13 ), TN( 18 ), RTEMS_RB_BLACK },
0895   { 8, TN( 18 ), NULL, TN( 16 ), RTEMS_RB_BLACK },
0896   { 8, TN( 17 ), NULL, NULL, RTEMS_RB_RED },
0897   { 9, TN( 14 ), TN( 17 ), TN( 27 ), RTEMS_RB_BLACK },
0898   { 10, TN( 27 ), NULL, NULL, RTEMS_RB_RED },
0899   { 13, TN( 18 ), TN( 20 ), TN( 28 ), RTEMS_RB_BLACK },
0900   { 14, TN( 27 ), NULL, NULL, RTEMS_RB_RED }
0901 };
0902 
0903 static const TestNodeDescription random_ops_tree_unique_31[] = {
0904   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0905   { 2, TN( 5 ), TN( 0 ), NULL, RTEMS_RB_BLACK },
0906   { 5, TN( 11 ), TN( 2 ), TN( 9 ), RTEMS_RB_BLACK },
0907   { 7, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0908   { 9, TN( 5 ), TN( 7 ), NULL, RTEMS_RB_BLACK },
0909   { 11, NULL, TN( 5 ), TN( 21 ), RTEMS_RB_BLACK },
0910   { 14, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0911   { 16, TN( 21 ), TN( 14 ), TN( 18 ), RTEMS_RB_BLACK },
0912   { 18, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0913   { 21, TN( 11 ), TN( 16 ), TN( 30 ), RTEMS_RB_BLACK },
0914   { 30, TN( 21 ), NULL, NULL, RTEMS_RB_BLACK }
0915 };
0916 
0917 static const TestNodeDescription random_ops_tree_multiple_31[] = {
0918   { 0, TN( 2 ), NULL, NULL, RTEMS_RB_RED },
0919   { 1, TN( 5 ), TN( 0 ), NULL, RTEMS_RB_BLACK },
0920   { 2, TN( 11 ), TN( 2 ), TN( 9 ), RTEMS_RB_BLACK },
0921   { 3, TN( 9 ), NULL, NULL, RTEMS_RB_RED },
0922   { 4, TN( 5 ), TN( 7 ), NULL, RTEMS_RB_BLACK },
0923   { 5, NULL, TN( 5 ), TN( 21 ), RTEMS_RB_BLACK },
0924   { 7, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0925   { 8, TN( 21 ), TN( 14 ), TN( 18 ), RTEMS_RB_BLACK },
0926   { 9, TN( 16 ), NULL, NULL, RTEMS_RB_RED },
0927   { 10, TN( 11 ), TN( 16 ), TN( 30 ), RTEMS_RB_BLACK },
0928   { 15, TN( 21 ), NULL, NULL, RTEMS_RB_BLACK }
0929 };
0930 
0931 #define RANDOM_OPS_TREE( i ) \
0932   { &random_ops_tree_multiple_##i[ 0 ], &random_ops_tree_unique_##i[ 0 ] }
0933 
0934 static const TestNodeDescription *const random_ops_trees[][2] = {
0935   RANDOM_OPS_TREE( 1 ),
0936   RANDOM_OPS_TREE( 2 ),
0937   RANDOM_OPS_TREE( 3 ),
0938   RANDOM_OPS_TREE( 4 ),
0939   RANDOM_OPS_TREE( 5 ),
0940   RANDOM_OPS_TREE( 6 ),
0941   RANDOM_OPS_TREE( 7 ),
0942   RANDOM_OPS_TREE( 8 ),
0943   RANDOM_OPS_TREE( 9 ),
0944   RANDOM_OPS_TREE( 10 ),
0945   RANDOM_OPS_TREE( 11 ),
0946   RANDOM_OPS_TREE( 12 ),
0947   RANDOM_OPS_TREE( 13 ),
0948   RANDOM_OPS_TREE( 14 ),
0949   RANDOM_OPS_TREE( 15 ),
0950   RANDOM_OPS_TREE( 16 ),
0951   RANDOM_OPS_TREE( 17 ),
0952   RANDOM_OPS_TREE( 18 ),
0953   RANDOM_OPS_TREE( 19 ),
0954   RANDOM_OPS_TREE( 20 ),
0955   RANDOM_OPS_TREE( 21 ),
0956   RANDOM_OPS_TREE( 22 ),
0957   RANDOM_OPS_TREE( 23 ),
0958   RANDOM_OPS_TREE( 24 ),
0959   RANDOM_OPS_TREE( 25 ),
0960   RANDOM_OPS_TREE( 26 ),
0961   RANDOM_OPS_TREE( 27 ),
0962   RANDOM_OPS_TREE( 28 ),
0963   RANDOM_OPS_TREE( 29 ),
0964   RANDOM_OPS_TREE( 30 ),
0965   RANDOM_OPS_TREE( 31 )
0966 };
0967 
0968 #define RANDOM_OPS_TREE_COUNT( i ) \
0969   { \
0970     RTEMS_ARRAY_SIZE( random_ops_tree_multiple_##i ), \
0971     RTEMS_ARRAY_SIZE( random_ops_tree_unique_##i ) \
0972   }
0973 
0974 static const size_t random_ops_tree_counts[][2] = {
0975   RANDOM_OPS_TREE_COUNT( 1 ),
0976   RANDOM_OPS_TREE_COUNT( 2 ),
0977   RANDOM_OPS_TREE_COUNT( 3 ),
0978   RANDOM_OPS_TREE_COUNT( 4 ),
0979   RANDOM_OPS_TREE_COUNT( 5 ),
0980   RANDOM_OPS_TREE_COUNT( 6 ),
0981   RANDOM_OPS_TREE_COUNT( 7 ),
0982   RANDOM_OPS_TREE_COUNT( 8 ),
0983   RANDOM_OPS_TREE_COUNT( 9 ),
0984   RANDOM_OPS_TREE_COUNT( 10 ),
0985   RANDOM_OPS_TREE_COUNT( 11 ),
0986   RANDOM_OPS_TREE_COUNT( 12 ),
0987   RANDOM_OPS_TREE_COUNT( 13 ),
0988   RANDOM_OPS_TREE_COUNT( 14 ),
0989   RANDOM_OPS_TREE_COUNT( 15 ),
0990   RANDOM_OPS_TREE_COUNT( 16 ),
0991   RANDOM_OPS_TREE_COUNT( 17 ),
0992   RANDOM_OPS_TREE_COUNT( 18 ),
0993   RANDOM_OPS_TREE_COUNT( 19 ),
0994   RANDOM_OPS_TREE_COUNT( 20 ),
0995   RANDOM_OPS_TREE_COUNT( 21 ),
0996   RANDOM_OPS_TREE_COUNT( 22 ),
0997   RANDOM_OPS_TREE_COUNT( 23 ),
0998   RANDOM_OPS_TREE_COUNT( 24 ),
0999   RANDOM_OPS_TREE_COUNT( 25 ),
1000   RANDOM_OPS_TREE_COUNT( 26 ),
1001   RANDOM_OPS_TREE_COUNT( 27 ),
1002   RANDOM_OPS_TREE_COUNT( 28 ),
1003   RANDOM_OPS_TREE_COUNT( 29 ),
1004   RANDOM_OPS_TREE_COUNT( 30 ),
1005   RANDOM_OPS_TREE_COUNT( 31 )
1006 };
1007 
1008 static uint32_t SimpleRandom( uint32_t v )
1009 {
1010   v *= 1664525;
1011   v += 1013904223;
1012 
1013   return v;
1014 }
1015 
1016 static void RandomOps( size_t n, bool unique )
1017 {
1018   VisitorContext ctx = {
1019     .current = 0,
1020     .count = random_ops_tree_counts[ n - 1 ][ unique ],
1021     .tree = random_ops_trees[ n - 1 ][ unique ]
1022   };
1023   RBTree_Control tree;
1024   TestNode      *nodes;
1025   size_t         m;
1026   size_t         s;
1027   uint32_t       v;
1028   size_t         i;
1029 
1030   nodes = &node_array[ 0 ];
1031   m = n * n * n;
1032   s = unique ? 1 : 2;
1033   v = 0xdeadbeef;
1034   _RBTree_Initialize_empty( &tree );
1035 
1036   memset( nodes, 0, n * sizeof( *nodes ) );
1037 
1038   for ( i = 0; i < n; ++i ) {
1039     nodes[ i ].key = (int) ( i / s );
1040   }
1041 
1042   for ( i = 0; i < m; ++i ) {
1043     size_t j = ( v >> 13 ) % n;
1044     TestNode *tn = &nodes[ j ];
1045 
1046     if ( tn->id == 0 ) {
1047       tn->id = 1;
1048       _RBTree_Initialize_node( &tn->Node );
1049       _RBTree_Insert_inline( &tree, &tn->Node, &tn->key, Less );
1050     } else {
1051       tn->id = 0;
1052       _RBTree_Extract( &tree, &tn->Node );
1053     }
1054 
1055     T_ne_int( VerifyTree( _RBTree_Root( &tree ) ), -1 );
1056 
1057     v = SimpleRandom( v );
1058   }
1059 
1060   _RBTree_Iterate( &tree, VisitNodes, &ctx );
1061   T_true( ctx.current == ctx.count );
1062 }
1063 
1064 /**
1065  * @brief Call _RBTree_Initialize_one() and check the tree properties.
1066  */
1067 static void ScoreRbtreeUnitRbtree_Action_0( void )
1068 {
1069   RBTree_Control tree;
1070   RBTree_Node    node;
1071 
1072   _RBTree_Initialize_node( &node );
1073   _RBTree_Initialize_one( &tree, &node );
1074 
1075   /*
1076    * Check that the tree is not emtpy.
1077    */
1078   T_false( _RBTree_Is_empty( &tree ) );
1079 
1080   /*
1081    * Check that the tree root is is the only node.
1082    */
1083   T_true( _RBTree_Is_root( &node ) );
1084 
1085   /*
1086    * Check that the node is not off the tree.
1087    */
1088   T_false( _RBTree_Is_node_off_tree( &node ) );
1089 
1090   /*
1091    * Check that the node has no left child.
1092    */
1093   T_null( _RBTree_Left( &node ) );
1094 
1095   /*
1096    * Check that the node has no right child.
1097    */
1098   T_null( _RBTree_Right( &node ) );
1099 
1100   /*
1101    * Check that the node has no parent.
1102    */
1103   T_null( _RBTree_Parent( &node ) );
1104 
1105   /*
1106    * Check that the node has no successor.
1107    */
1108   T_null( _RBTree_Successor( &node ) );
1109 
1110   /*
1111    * Check that the node has no predecessor.
1112    */
1113   T_null( _RBTree_Predecessor( &node ) );
1114 
1115   /*
1116    * Check that the minimum node is the node.
1117    */
1118   T_eq_ptr( _RBTree_Minimum( &tree ), &node );
1119 
1120   /*
1121    * Check that the maximum node is the node.
1122    */
1123   T_eq_ptr( _RBTree_Maximum( &tree ), &node );
1124 
1125   /*
1126    * Check that the tree is emtpy after extraction of the node.
1127    */
1128   _RBTree_Extract( &tree, &node );
1129   T_true( _RBTree_Is_empty( &tree ) );
1130 }
1131 
1132 /**
1133  * @brief Call _RBTree_Insert_inline() and check the return status for a sample
1134  *   set of nodes.
1135  */
1136 static void ScoreRbtreeUnitRbtree_Action_1( void )
1137 {
1138   RBTree_Control tree;
1139   TestNode       a;
1140   TestNode       b;
1141   TestNode       c;
1142   bool           is_new_minimum;
1143 
1144   _RBTree_Initialize_empty( &tree );
1145 
1146   /*
1147    * Insert the first node.  Check that it is the new minimum node.
1148    */
1149   _RBTree_Initialize_node( &b.Node );
1150   b.key = 2;
1151   is_new_minimum = _RBTree_Insert_inline( &tree, &b.Node, &b.key, Less );
1152   T_true( is_new_minimum );
1153 
1154   /*
1155    * Insert the second node.  Check that it is not the new minimum node.
1156    */
1157   _RBTree_Initialize_node( &c.Node );
1158   c.key = 3;
1159   is_new_minimum = _RBTree_Insert_inline( &tree, &c.Node, &c.key, Less );
1160   T_false( is_new_minimum );
1161 
1162   /*
1163    * Insert the third node.  Check that it is the new minimum node.
1164    */
1165   _RBTree_Initialize_node( &a.Node );
1166   a.key = 1;
1167   is_new_minimum = _RBTree_Insert_inline( &tree, &a.Node, &a.key, Less );
1168   T_true( is_new_minimum );
1169 }
1170 
1171 /**
1172  * @brief Call _RBTree_Insert_inline() and _RBTree_Extract() for a sample set
1173  *   of trees.
1174  */
1175 static void ScoreRbtreeUnitRbtree_Action_2( void )
1176 {
1177   size_t n;
1178 
1179   for ( n = 0; n < RTEMS_ARRAY_SIZE( random_ops_trees ); ++n ) {
1180     RandomOps( n + 1, true );
1181     RandomOps( n + 1, false );
1182   }
1183 }
1184 
1185 /**
1186  * @fn void T_case_body_ScoreRbtreeUnitRbtree( void )
1187  */
1188 T_TEST_CASE( ScoreRbtreeUnitRbtree )
1189 {
1190   ScoreRbtreeUnitRbtree_Action_0();
1191   ScoreRbtreeUnitRbtree_Action_1();
1192   ScoreRbtreeUnitRbtree_Action_2();
1193 }
1194 
1195 /** @} */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!