int getCurrentSourceIndex (bool input) const
    {
        OSType currentSourceID = 0;
        UInt32 size = sizeof (currentSourceID);
        int result = -1;

        AudioObjectPropertyAddress pa;
        pa.mSelector = kAudioDevicePropertyDataSource;
        pa.mScope = input ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;
        pa.mElement = kAudioObjectPropertyElementMaster;

        if (deviceID != 0)
        {
            if (OK (AudioObjectGetPropertyData (deviceID, &pa, 0, 0, &size, &currentSourceID)))
            {
                HeapBlock <OSType> types;
                const int num = getAllDataSourcesForDevice (deviceID, types);

                for (int i = 0; i < num; ++i)
                {
                    if (types[num] == currentSourceID)
                    {
                        result = i;
                        break;
                    }
                }
            }
        }

        return result;
    }
TEST_F(MesosSchedulerDriverTest, MetricsEndpoint)
{
  Try<Owned<cluster::Master>> master = StartMaster();
  ASSERT_SOME(master);

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);

  Future<Nothing> registered;
  EXPECT_CALL(sched, registered(&driver, _, _))
    .WillOnce(FutureSatisfy(&registered));

  ASSERT_EQ(DRIVER_RUNNING, driver.start());

  AWAIT_READY(registered);

  Future<process::http::Response> response =
    process::http::get(process::metrics::internal::metrics, "snapshot");

  AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response);
  AWAIT_EXPECT_RESPONSE_HEADER_EQ(APPLICATION_JSON, "Content-Type", response);

  Try<JSON::Object> parse = JSON::parse<JSON::Object>(response->body);

  ASSERT_SOME(parse);

  JSON::Object metrics = parse.get();

  EXPECT_EQ(1u, metrics.values.count("scheduler/event_queue_messages"));
  EXPECT_EQ(1u, metrics.values.count("scheduler/event_queue_dispatches"));

  driver.stop();
  driver.join();
}
    //==============================================================================
    StringArray getSources (bool input)
    {
        StringArray s;
        HeapBlock <OSType> types;
        const int num = getAllDataSourcesForDevice (deviceID, types);

        for (int i = 0; i < num; ++i)
        {
            AudioValueTranslation avt;
            char buffer[256];

            avt.mInputData = &(types[i]);
            avt.mInputDataSize = sizeof (UInt32);
            avt.mOutputData = buffer;
            avt.mOutputDataSize = 256;

            UInt32 transSize = sizeof (avt);

            AudioObjectPropertyAddress pa;
            pa.mSelector = kAudioDevicePropertyDataSourceNameForID;
            pa.mScope = input ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;
            pa.mElement = kAudioObjectPropertyElementMaster;

            if (OK (AudioObjectGetPropertyData (deviceID, &pa, 0, 0, &transSize, &avt)))
            {
                DBG (buffer);
                s.add (buffer);
            }
        }

        return s;
    }
Exemple #4
0
static void
cxn_msg_rx(indigo_cxn_id_t cxn_id, of_object_t *obj)
{
    printf("Got msg from %d: type %d\n", cxn_id, obj->object_id);

    /* Just respond to echo request */
    if (obj->object_id == OF_ECHO_REQUEST) {
        of_echo_request_t *echo;
        of_echo_reply_t *reply;
        of_octets_t data;
        uint32_t xid;

        echo = (of_echo_request_t *)obj;
        of_echo_request_xid_get(echo, &xid);
        printf("Respond to echo with xid 0x%x\n", xid);
        if ((reply = of_echo_reply_new(echo->version)) == NULL) {
            printf("Could not allocate echo response obj\n");
            goto done;
        }

        of_echo_request_data_get(echo, &data);
        if (data.bytes) {
            OK(of_echo_reply_data_set(reply, &data));
        }

        of_echo_reply_xid_set(reply, xid);

        indigo_cxn_send_controller_message(cxn_id, reply);
    }

 done:
    of_object_delete(obj);
    got_cxn_msg = 1;
}
Exemple #5
0
double cOneTestLSQ::Correl(const Pt2dr & aDec) const
{
   if (! OK(aDec)) return -1;

   double aSom2= 0;
   double aSom22= 0;
   double aSom12= 0;
   int aCpt=0;

   for(int aKx=-mNbW; aKx<=mNbW; aKx++)
   {
       for(int aKy=-mNbW; aKy<=mNbW; aKy++)
       {
          Pt2dr aP2 = aDec+mIm2->PVois(aKx,aKy);

          double aV2 =  mIm2->GetVal(aP2);
          double aV1 = mValsIm1[aCpt];
          aSom2 += aV2;
          aSom12 += aV1*aV2;
          aSom22 += ElSquare(aV2);
         
          aCpt++;
       }
    }

    aSom2 /= mSomP;
    aSom12 /= mSomP;
    aSom22 /= mSomP;

    aSom12 -= mSom1 * aSom2;
    aSom22 -= ElSquare(aSom2);


    return aSom12 * sqrt(std::max(1e-5,aSom22*mSom11));
}
bool CShaderProgram::Enable()
{
  if (OK())
  {
    glUseProgram(m_shaderProgram);
    if (OnEnabled())
    {
      if (!m_validated)
      {
        // validate the program
        GLint params[4];
        glValidateProgram(m_shaderProgram);
        glGetProgramiv(m_shaderProgram, GL_VALIDATE_STATUS, params);
        if (params[0] != GL_TRUE)
        {
          GLchar log[LOG_SIZE];
          kodi::Log(ADDON_LOG_ERROR, "GL: Error validating shader");
          glGetProgramInfoLog(m_shaderProgram, LOG_SIZE, nullptr, log);
          kodi::Log(ADDON_LOG_ERROR, "%s", log);
        }
        m_validated = true;
      }
      return true;
    }
    else
    {
      glUseProgram(0);
      return false;
    }
    return true;
  }
  return false;
}
cRamp::cRamp( const char* fileName,bool declaredScansOnly ) : 
  m_filename(fileName), m_declaredScansOnly(declaredScansOnly), m_runInfo()
{
   m_handle = rampOpenFile(fileName);
   m_scanOffsets = NULL;
   m_runInfo = NULL;
   m_lastScan = 0;   
   if (!OK()) {
     // HENRY -- I would prefer this to be silent, and let the caller deals with it
     // cout << "Error: Could not open file " << fileName << ": " << strerror(errno) << endl;
     // END HENRY
   } else {

      m_runInfo = getRunInfo();

      // HENRY -- always read index to set scan count, since scan count
      // declared at the top of the mzXML file is unreliable now that
      // there are missing scans.
      // This will also set the structs m_scanOffsets, and the value m_lastScan
      
      //      if (m_runInfo->m_data.scanCount < 0) { // undeclared scan count
         // this will provoke reading of index, which sets scan count
         rampScanInfo* tmp = getScanHeaderInfo ( 1 );
         free(tmp);
	 // }
      // END HENRY
   }
}
Exemple #8
0
Fichier : cli.c Projet : modul/iris
static void do_load()
{
	input_stop();
	conf_load();
	OK();
	input_calibrate(CHANNELS);
	input_start();
}
Exemple #9
0
/*
**++
**  ROUTINE:	netlib___alloc_ctx
**
**  FUNCTIONAL DESCRIPTION:
**
**  	Allocates some memory.
**
**  RETURNS:	cond_value
**
**  PROTOTYPE:
**
**  	netlib___alloc_ctx(unsigned int size, void *ptr)
**
**  IMPLICIT INPUTS:	None.
**
**  IMPLICIT OUTPUTS:	None.
**
**  COMPLETION CODES:	None.
**
**  SIDE EFFECTS:   	None.
**
**--
*/
unsigned int netlib___alloc_ctx (struct CTX **ctxp, unsigned int specsize) {

    struct CTX *ctx;
    unsigned int status, fullsize, aststat;

    BLOCK_ASTS(aststat);
    if (netlib_synch_efn == 0xffffffff) {
    	status = lib$get_ef(&netlib_synch_efn);
    	if (!OK(status)) {
    	    UNBLOCK_ASTS(aststat);
    	    return status;
    	}
    }
    if (netlib_asynch_efn == 0xffffffff) {
    	status = lib$get_ef(&netlib_asynch_efn);
    	if (!OK(status)) {
    	    UNBLOCK_ASTS(aststat);
    	    return status;
    	}
    }

    fullsize = specsize + CTX_S_CTXDEF;
    if (ctxzone == 0) {
    	unsigned int algorithm=LIB$K_VM_FIXED;
    	unsigned int flags=LIB$M_VM_GET_FILL0|LIB$M_VM_EXTEND_AREA;
    	status = lib$create_vm_zone(&ctxzone, &algorithm, &fullsize, &flags);
    	if (!OK(status)) {
    	    UNBLOCK_ASTS(aststat);
    	    return status;
    	}
    }

    status = lib$get_vm(&fullsize, &ctx, &ctxzone);
    if (OK(status)) {
    	ctx->specctx = ctx + 1;
    	ctx->specctx_size = specsize;
    	if (!OK(status)) lib$free_vm(&fullsize, &ctx, &ctxzone);
    	*ctxp = ctx;

    }

    UNBLOCK_ASTS(aststat);

    return status;

} /* netlib___alloc_ctx */
Exemple #10
0
struct CFCClass*
CFCTest_parse_class(CFCTest *test, CFCParser *parser, const char *src) {
    CFCBase *result = CFCParser_parse(parser, src);
    OK(test, result != NULL, "parse class");
    STR_EQ(test, CFCBase_get_cfc_class(result),
           "Clownfish::CFC::Model::Class", "result class");
    return (struct CFCClass*)result;
}
Exemple #11
0
struct CFCMethod*
CFCTest_parse_method(CFCTest *test, CFCParser *parser, const char *src) {
    CFCBase *result = CFCParser_parse(parser, src);
    OK(test, result != NULL, "parse '%s'", src);
    STR_EQ(test, CFCBase_get_cfc_class(result),
           "Clownfish::CFC::Model::Method", "result class of '%s'", src);
    return (struct CFCMethod*)result;
}
 bool open (const double newSampleRate, const BitArray& newChannels)
 {
     reservoirSize = 0;
     reservoirCapacity = 16384;
     reservoir.setSize (actualNumChannels * reservoirCapacity * sizeof (float));
     return openClient (newSampleRate, newChannels)
             && (numChannels == 0 || OK (client->GetService (__uuidof (IAudioCaptureClient), (void**) &captureClient)));
 }
void CShaderProgram::Disable()
{
  if (OK())
  {
    glUseProgram(0);
    OnDisabled();
  }
}
Exemple #14
0
int GameMapSet::setLevel(int l) {
  if (l != m_level && OK(l)) {
    m_level = l;
    emit levelChanged();
  }

  return m_level;
}
static void
test_inside (int * test)
{
    int cell;
    int direction;
    cell = 0;
    direction = 4;
    OK (inside (cell, direction), (*test), "%d %d is inside", cell, direction);
    cell = 0;
    direction = 0;
    OK (! inside (cell, direction), (*test), "%d %d is not inside", cell, direction);
    cell = 80;
    direction = 0;
    OK (inside (cell, direction), (*test), "%d %d is inside", cell, direction);
    cell = 80;
    direction = 7;
    OK (! inside (cell, direction), (*test), "%d %d is not inside", cell, direction);
}
Exemple #16
0
bool Data_Buffer::Size (size_t num) 
{
	if (num > 0 && (num > max_size || !OK ())) {
		if (!Max_Size (num)) return (false);
	}
	size = num; 
	get_ptr = buffer;
	return (true);
}
Exemple #17
0
/* Called after every test to clean up */
static int teardown(void **state)
{
    uc_engine *uc = *state;

    OK(uc_close(uc));

    *state = NULL;
    return 0;
}
Exemple #18
0
/* Called before every test to set up a new instance */
static int setup32(void **state)
{
    uc_engine *uc;

    OK(uc_open(UC_ARCH_X86, UC_MODE_32, &uc));

    *state = uc;
    return 0;
}
Exemple #19
0
/*
**++
**  ROUTINE:	netlib_bind
**
**  FUNCTIONAL DESCRIPTION:
**
**  	tbs
**
**  RETURNS:	cond_value, longword (unsigned), write only, by value
**
**  PROTOTYPE:
**
**  	tbs
**
**  IMPLICIT INPUTS:	None.
**
**  IMPLICIT OUTPUTS:	None.
**
**  COMPLETION CODES:
**
**
**  SIDE EFFECTS:   	None.
**
**--
*/
unsigned int netlib_bind (struct CTX **xctx, struct SINDEF *sa,
    	    	    	    unsigned int *salen, struct NETLIBIOSBDEF *iosb,
    	    	    	    void (*astadr)(), void *astprm) {

    struct CTX *ctx;
    unsigned int status;
    ITMLST2 sockdsc;
    int argc;
    static unsigned int one = 1;

    VERIFY_CTX(xctx, ctx);
    SETARGCOUNT(argc);

    if (argc < 3) return SS$_INSFARG;
    if (sa == 0 || salen == 0) return SS$_BADPARAM;
    if (*salen < sizeof(struct SINDEF)) return SS$_BADPARAM;

    if (!(ctx->flags & CTX_M_USER_SET_REUSEADDR)) {
    	ITMLST2 rulst, sockopt;
    	ITMLST2_INIT(rulst, UCX$C_SOCKOPT, sizeof(sockopt), &sockopt);
    	ITMLST2_INIT(sockopt, NETLIB_K_OPTION_REUSEADDR, sizeof(one), &one);
    	sys$qiow(netlib_synch_efn, ctx->chan, IO$_SETMODE, 0, 0, 0,
    	    	    0, 0, 0, 0, &rulst, 0);
    }

    ITMLST2_INIT(sockdsc, 0, *salen, sa);

    if (argc > 4 && astadr != 0) {
    	struct IOR *ior;
    	GET_IOR(ior, ctx, iosb, astadr, (argc > 5) ? astprm : 0);
    	status = sys$qio(netlib_asynch_efn, ctx->chan, IO$_SETMODE, &ior->iosb,
    	    	    	    io_completion, ior, 0, 0, &sockdsc, 0, 0, 0);
    	if (!OK(status)) FREE_IOR(ior);
    } else {
    	struct NETLIBIOSBDEF myiosb;
    	status = sys$qiow(netlib_synch_efn, ctx->chan, IO$_SETMODE, &myiosb,
    	    	    	    0, 0, 0, 0, &sockdsc, 0, 0, 0);
    	if (OK(status)) status = netlib___cvt_status(&myiosb);
    	if (argc > 3 && iosb != 0) netlib___cvt_iosb(iosb, &myiosb);
    }

    return status;

} /* netlib_bind */
Exemple #20
0
int
cubeb_init(cubeb ** context, char const * context_name)
{
  int (* init[])(cubeb **, char const *) = {
#if defined(USE_JACK)
    jack_init,
#endif
#if defined(USE_PULSE)
    pulse_init,
#endif
#if defined(USE_ALSA)
    alsa_init,
#endif
#if defined(USE_AUDIOUNIT)
    audiounit_init,
#endif
#if defined(USE_WASAPI)
    wasapi_init,
#endif
#if defined(USE_WINMM)
    winmm_init,
#endif
#if defined(USE_SNDIO)
    sndio_init,
#endif
#if defined(USE_OPENSL)
    opensl_init,
#endif
#if defined(USE_AUDIOTRACK)
    audiotrack_init,
#endif
#if defined(USE_KAI)
    kai_init,
#endif
  };
  int i;

  if (!context) {
    return CUBEB_ERROR_INVALID_PARAMETER;
  }

  for (i = 0; i < NELEMS(init); ++i) {
    if (init[i](context, context_name) == CUBEB_OK) {
      /* Assert that the minimal API is implemented. */
#define OK(fn) assert((* context)->ops->fn)
      OK(get_backend_id);
      OK(destroy);
      OK(stream_init);
      OK(stream_destroy);
      OK(stream_start);
      OK(stream_stop);
      OK(stream_get_position);
      return CUBEB_OK;
    }
  }

  return CUBEB_ERROR;
}
Exemple #21
0
/*
**++
**  ROUTINE:	sp_receive
**
**  FUNCTIONAL DESCRIPTION:
**
**  	Get some output from the subprocess, if any.  Uses IO$M_NOW modifier
**  so that if there isn't anything available, we return an error status
**  rather than blocking until something comes up.
**
**  RETURNS:	cond_value, longword (unsigned), write only, by value
**
**  PROTOTYPE:
**
**  	sp_receive(SPHANDLE *ctxpp, struct dsc$descriptor *rcvstr,
**  	    	    	int *rcvlen)
**
**  IMPLICIT INPUTS:	None.
**
**  IMPLICIT OUTPUTS:	None.
**
**  COMPLETION CODES:
**  	    SS$_NORMAL:  normal successful completion
**  	    SS$_NONEXPR: subprocess doesn't exist any more
**
**  SIDE EFFECTS:   	None.
**
**--
*/
unsigned int sp_receive (SPHANDLE *ctxpp, void *rcvstr, int *rcvlen) {

    SPHANDLE ctx;
    unsigned int status, efstate;

    ctx = *ctxpp;
    if (sys$readef(ctx->termefn, &efstate) != SS$_WASCLR) return SS$_NONEXPR;

    status = sys$qiow(0, ctx->outchn, IO$_READVBLK|IO$M_NOW, ctx->iosb,
    	    	0, 0, ctx->bufptr, ctx->bufsiz, 0, 0, 0, 0);
    if (OK(status)) status = ctx->iosb[0];
    if (OK(status)) {
    	str$copy_r(rcvstr, &ctx->iosb[1], ctx->bufptr);
    	if (rcvlen) *rcvlen = ctx->iosb[1];
    }

    return status;

} /* sp_receive */
Exemple #22
0
/**
 * Base class implementation of one-time dictionary initialization
 *
 * @param _this This instance
 * @return O_K if successful, an error code otherwise
 */
INT16 CDlpObject_AutoRegisterWords(CDlpObject* _this)
{
  INT16 nErr = O_K;
  DEBUGMSG(-1,"CDlpObject_AutoRegisterWords for '%s'",_this->m_lpInstanceName,0,0);
  nErr = CDlpObject_UnregisterAllWords(_this);
  if (!OK(nErr)) return nErr;

  REGISTER_FIELD("check","",LPMV(m_nCheck),NULL,"Verbose level",0,T_SHORT,1,"",0)
  return O_K;
}
int main()
{
	int i,j,now,cur,max;
	FILE *fin  = fopen ("ariprog.in", "r");
    FILE *fout = fopen ("ariprog.out", "w");
	fscanf(fin,"%d %d",&n,&m);
	for(i=0;i<=m;i++)
		exist[i]=i*i;
	for(i=0;i<=m;i++)
	{
		for(j=i;j<=m;j++)
			Is[exist[i]+exist[j]]=1;
	}
	max=m*m<<1;
	for(i=0,cur=1;i<=max;i++)
	{
		if(Is[i])
			exist[cur++]=i;
	}
	cur--;
	for(st=1;(now=i*(n-1))<=max;st++)
	{
		for(j=1;now+exist[j]<=max;j++)
		{
			if(OK(exist[j],i,n))
				break;
		}
		if(now+exist[j]<=max)
			break;
	}
	for(i=st;(now=i*(n-1))<=max;i+=st)
	{
		for(j=1;now+exist[j]<=max;j++)
		{
			if(OK(exist[j],i,n))
				fprintf(fout,"%d %d\n",exist[j],i);
		}
	}
	if(!yep)
		fprintf(fout,"NONE\n");
	return 0;
}
Exemple #24
0
static void
test_ether_aton_bad(void)
{
	struct ether_addr *ep;

	testnum++;
	ep = ether_aton(ether_aton_bad_string);
	if (ep != NULL)
		NOTOK("returned success");
	OK();
}
Exemple #25
0
static void
test_ether_line_bad_2(void)
{
	struct ether_addr e;
	char hostname[256];

	testnum++;
	if (ether_line(ether_line_bad_2_string, &e, hostname) == 0)
		NOTOK("returned success");
	OK();
}
Exemple #26
0
/*
**++
**  ROUTINE:	netlib_server_setup
**
**  FUNCTIONAL DESCRIPTION:
**
**  	Create a "server_setup".
**
**  RETURNS:	cond_value, longword (unsigned), write only, by value
**
**  PROTOTYPE:
**
**  	tbs
**
**  IMPLICIT INPUTS:	None.
**
**  IMPLICIT OUTPUTS:	None.
**
**  COMPLETION CODES:
**
**
**  SIDE EFFECTS:   	None.
**
**--
*/
unsigned int netlib_server_setup (struct CTX **xctx, struct SINDEF *sa,
    	    	    	    	    	unsigned int *salen) {

    struct CTX *ctx;
    struct NETLIBIOSBDEF myiosb;
    struct {
    	unsigned short protocol;
    	unsigned char  type;
    	unsigned char  domain;
    } sockdef;
    unsigned int status;

    static $DESCRIPTOR(device, "SYS$NET");

    status = netlib___alloc_ctx(&ctx, SPECCTX_SIZE);
    if (!OK(status)) return status;

    status = sys$assign(&device, &ctx->chan, 0, 0);
    if (!OK(status)) {
    	netlib___free_ctx(ctx);
    	return status;
    }

    sockdef.protocol = UCX$C_TCP;
    sockdef.type = INET_PROTYP$C_STREAM;
    sockdef.domain = UCX$C_AUXS;

    status = sys$qiow(netlib_synch_efn, ctx->chan, IO$_SETMODE,
    	    	    	&myiosb, 0, 0,
    	    	    	&sockdef, 0, 0, 0, 0, 0);
    if (OK(status)) status = netlib___cvt_status(&myiosb);
    if (!OK(status)) {
    	sys$dassgn(ctx->chan);
    	netlib___free_ctx(ctx);
    	return status;
    }

    *xctx = ctx;
    return SS$_NORMAL;

} /* netlib_server_setup */
Exemple #27
0
/*************************************************************************
* FUNCTION      :   RPMTransaction_Set::Problems                         *
* ARGUMENTS     :   interp                                               *
* RETURNS       :   TCL_OK or TCL_ERROR                                  *
* EXCEPTIONS    :   none                                                 *
* PURPOSE       :   Return current problem set as TCL list               *
*************************************************************************/
int RPMTransaction_Set::Problems(Tcl_Interp *interp,int , Tcl_Obj *const [])
{
    rpmps problems = rpmtsProblems(transaction);
    int num_probs      = rpmpsNumProblems(problems);
    Tcl_Obj *rv = 0;
    for (int i = 0; i < num_probs; ++i)
    {
        rpmProblem what = &problems->probs[i];
        rv = Grow_list(rv,RPMPRoblem_Obj::Create_from_problem(*what));
    }
    return OK(rv);
}
void    key_GetPassword(void)
{
  if (bKey == bKEY_ENTER)
  {
    if (enKeyboard == KBD_ENTER)
    {
      enKeyboard = KBD_INPUT2;

      ShowHi(szPassword);
      ShowLo(szMaskPass);

      ClearPassTwo();
      ibX = 3;
    }
    else if (enKeyboard == KBD_INPUT2)
    { 
      if ((memcmp(mpbPassOne, mpbPassTwo, 10) == 0) || SuperUser())
      {       
        enKeyboard = KBD_BEGIN;
        OK();

        boSetPassword = true;
        SaveCache(&chSetPassword);

        enGlobal = GLB_REPROGRAM;
        Setting();

//        AddSysRecord(EVE_PASSWORD);
      }
      else 
      {
        enKeyboard = KBD_ENTER;
        LongBeep();

        Error();
      }
    }
  }


  else if (bKey < 10)
  {
    if (enKeyboard == KBD_INPUT2)
    {
      if (ibX < 13)
      {
        mpbPassTwo[ibX-3] = bKey;
        szLo[ibX++] = '*';
      }
    }
  }
  else Beep();
}
static void
test_connect(struct sockaddr_un *sun)
{
	int s;

	ANN();
	NEW_SOCKET(s);
	if (connect(s, (struct sockaddr *)sun, sizeof(*sun)) < 0)
		FAILERR("connect");
	(void)close(s);
	OK();
}
      void ObTabletJoinTest::SetUp()
      {
        tablet_join_info_.left_table_id_ = LEFT_TABLE_ID;
        tablet_join_info_.right_table_id_ = RIGHT_TABLE_ID;

        ObTabletJoin::JoinInfo join_info;

        OK(tablet_join_info_.join_condition_.push_back(1));

        join_info.left_column_id_ = 4;
        join_info.right_column_id_ = 2;
        OK(tablet_join_info_.join_column_.push_back(join_info));

        join_info.left_column_id_ = 5;
        join_info.right_column_id_ = 3;
        OK(tablet_join_info_.join_column_.push_back(join_info));

        join_info.left_column_id_ = 6;
        join_info.right_column_id_ = 4;
        OK(tablet_join_info_.join_column_.push_back(join_info));
      }