← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mariadb-5.5/vivid-proposed

« back to all changes in this revision

Viewing changes to storage/tokudb/ft-index/ft/tests/test-leafentry-child-txn.cc

  • Committer: Package Import Robot
  • Author(s): Otto Kekäläinen
  • Date: 2014-11-14 21:04:24 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20141114210424-xlyna0ozl11647o5
Tags: 5.5.40-0ubuntu0.14.10.1
https://launchpad.net/bugs/1391676
* SECURITY UPDATE: Update to 5.5.40 to fix security issues (LP: #1391676)
  - CVE-2014-6507
  - CVE-2014-6491
  - CVE-2014-6500
  - CVE-2014-6469
  - CVE-2014-6555
  - CVE-2014-6559
  - CVE-2014-6494
  - CVE-2014-6496
  - CVE-2014-6464
* Add bsdutils as mariadb-server dependency like upstream does in 5.5.40.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/tokudb/ft-index/ft/tests/test-leafentry-child-txn.cc
29
29
 
30
30
COPYRIGHT NOTICE:
31
31
 
32
 
  TokuDB, Tokutek Fractal Tree Indexing Library.
 
32
  TokuFT, Tokutek Fractal Tree Indexing Library.
33
33
  Copyright (C) 2007-2013 Tokutek, Inc.
34
34
 
35
35
DISCLAIMER:
91
91
#include <string.h>
92
92
 
93
93
#include "test.h"
94
 
#include "fttypes.h"
95
94
 
96
 
#include "ule.h"
97
 
#include "ule-internal.h"
 
95
#include "ft/ule.h"
 
96
#include "ft/ule-internal.h"
98
97
 
99
98
static void init_empty_ule(ULE ule) {
100
99
    ule->num_cuxrs = 0;
111
110
    ule->uxrs[index].xid    = xid;
112
111
}
113
112
 
114
 
static FT_MSG_S
115
 
msg_init(enum ft_msg_type type, XIDS xids,
116
 
         DBT *key, DBT *val) {
117
 
    FT_MSG_S msg;
118
 
    msg.type = type;
119
 
    msg.xids = xids;
120
 
    msg.u.id.key = key;
121
 
    msg.u.id.val = val;
122
 
    return msg;
123
 
}
124
 
 
125
113
//Test all the different things that can happen to a
126
114
//committed leafentry (logical equivalent of a committed insert).
127
115
static void
144
132
 
145
133
    // test case where we apply a message and the innermost child_id
146
134
    // is the same as the innermost committed TXNID    
147
 
    XIDS root_xids = xids_get_root_xids();
 
135
    XIDS root_xids = toku_xids_get_root_xids();
148
136
    TXNID root_txnid = 1000;
149
137
    TXNID child_id = 10;
150
138
    XIDS msg_xids_1;
151
139
    XIDS msg_xids_2;
152
 
    r = xids_create_child(root_xids, &msg_xids_1, root_txnid);
 
140
    r = toku_xids_create_child(root_xids, &msg_xids_1, root_txnid);
153
141
    assert(r==0);
154
 
    r = xids_create_child(msg_xids_1, &msg_xids_2, child_id);
 
142
    r = toku_xids_create_child(msg_xids_1, &msg_xids_2, child_id);
155
143
    assert(r==0);
156
144
 
157
145
    init_empty_ule(&ule_initial);
161
149
    add_committed_entry(&ule_initial, &val, 10);
162
150
 
163
151
    // now do the application of xids to the ule    
164
 
    FT_MSG_S msg;
165
152
    // do a commit
166
 
    msg = msg_init(FT_COMMIT_ANY, msg_xids_2, &key, &val);
167
 
    test_msg_modify_ule(&ule_initial, &msg);
168
 
    assert(ule->num_cuxrs == 2);
169
 
    assert(ule->uxrs[0].xid == TXNID_NONE);
170
 
    assert(ule->uxrs[1].xid == 10);
171
 
    assert(ule->uxrs[0].valp == &val_data_one);
172
 
    assert(ule->uxrs[1].valp == &val_data_two);
 
153
    {
 
154
        ft_msg msg(&key, &val, FT_COMMIT_ANY, ZERO_MSN, msg_xids_2);
 
155
        test_msg_modify_ule(&ule_initial, msg);
 
156
        assert(ule->num_cuxrs == 2);
 
157
        assert(ule->uxrs[0].xid == TXNID_NONE);
 
158
        assert(ule->uxrs[1].xid == 10);
 
159
        assert(ule->uxrs[0].valp == &val_data_one);
 
160
        assert(ule->uxrs[1].valp == &val_data_two);
 
161
    }
173
162
 
174
163
    // do an abort
175
 
    msg = msg_init(FT_ABORT_ANY, msg_xids_2, &key, &val);
176
 
    test_msg_modify_ule(&ule_initial, &msg);
177
 
    assert(ule->num_cuxrs == 2);
178
 
    assert(ule->uxrs[0].xid == TXNID_NONE);
179
 
    assert(ule->uxrs[1].xid == 10);
180
 
    assert(ule->uxrs[0].valp == &val_data_one);
181
 
    assert(ule->uxrs[1].valp == &val_data_two);
 
164
    {
 
165
        ft_msg msg(&key, &val, FT_ABORT_ANY, ZERO_MSN, msg_xids_2);
 
166
        test_msg_modify_ule(&ule_initial, msg);
 
167
        assert(ule->num_cuxrs == 2);
 
168
        assert(ule->uxrs[0].xid == TXNID_NONE);
 
169
        assert(ule->uxrs[1].xid == 10);
 
170
        assert(ule->uxrs[0].valp == &val_data_one);
 
171
        assert(ule->uxrs[1].valp == &val_data_two);
 
172
    }
182
173
 
183
174
    // do an insert
184
175
    val.data = &val_data_three;
185
 
    msg = msg_init(FT_INSERT, msg_xids_2, &key, &val);
186
 
    test_msg_modify_ule(&ule_initial, &msg);
187
 
    // now that message applied, verify that things are good
188
 
    assert(ule->num_cuxrs == 2);
189
 
    assert(ule->num_puxrs == 2);
190
 
    assert(ule->uxrs[0].xid == TXNID_NONE);
191
 
    assert(ule->uxrs[1].xid == 10);
192
 
    assert(ule->uxrs[2].xid == 1000);
193
 
    assert(ule->uxrs[3].xid == 10);
194
 
    assert(ule->uxrs[0].valp == &val_data_one);
195
 
    assert(ule->uxrs[1].valp == &val_data_two);
196
 
    assert(ule->uxrs[2].type == XR_PLACEHOLDER);
197
 
    assert(ule->uxrs[3].valp == &val_data_three);
198
 
    
 
176
    {
 
177
        ft_msg msg(&key, &val, FT_INSERT, ZERO_MSN, msg_xids_2);
 
178
        test_msg_modify_ule(&ule_initial, msg);
 
179
        // now that message applied, verify that things are good
 
180
        assert(ule->num_cuxrs == 2);
 
181
        assert(ule->num_puxrs == 2);
 
182
        assert(ule->uxrs[0].xid == TXNID_NONE);
 
183
        assert(ule->uxrs[1].xid == 10);
 
184
        assert(ule->uxrs[2].xid == 1000);
 
185
        assert(ule->uxrs[3].xid == 10);
 
186
        assert(ule->uxrs[0].valp == &val_data_one);
 
187
        assert(ule->uxrs[1].valp == &val_data_two);
 
188
        assert(ule->uxrs[2].type == XR_PLACEHOLDER);
 
189
        assert(ule->uxrs[3].valp == &val_data_three);
 
190
    } 
199
191
 
200
 
    xids_destroy(&msg_xids_2);
201
 
    xids_destroy(&msg_xids_1);
202
 
    xids_destroy(&root_xids);
 
192
    toku_xids_destroy(&msg_xids_2);
 
193
    toku_xids_destroy(&msg_xids_1);
 
194
    toku_xids_destroy(&root_xids);
203
195
 
204
196
}
205
197