def test_pubsubcpp(self):
        '''publish messages using basicpubcpp and verify basicsubcpp receives the messages'''
        my_print("\n----------Running pubsubcpp test----------\n")
        basicsubcpp_out = open('pubsub_basicsubcpp.out','w')
        basicsubcpp_err = open('pubsub_basicsubcpp.err','w')
        basicpubcpp_out = open('pubsub_basicpubcpp.out','w')
        ret1 = start_app("basicsubcpp","sub",args=["-v","-v","-v","-v"],stdout=basicsubcpp_out,stderr=basicsubcpp_err)

        ret2 = call_wait4text("Created inbound subscription","pubsub_basicsubcpp.out")
        ret3 = start_app("basicpubcpp","pub",stdout=basicpubcpp_out,stderr=subprocess.STDOUT)

        ret4 = call_wait4text("EXIT", "pubsub_basicsubcpp.out")
        ret5 = call_comparelog("pubsub_expectedsubcpp.out","pubsub_basicsubcpp.out")

        basicsubcpp_out.close()
        basicsubcpp_err.close()
        basicpubcpp_out.close()

        if ret1.poll() is None:
            kill_process(ret1.pid)
        if ret3.poll() is None:
            kill_process(ret3.pid)

 
        self.assertTrue(ret4==0)
        self.assertTrue(ret5==0)
    def test_ft_active_activec(self):
        '''start two basicftmemberc and verify that both go to active, if they belong to different groups'''
        my_print(
            "\n---------------Running basicftmemberc test active-active--------------\n"
        )
        ftmemberc1_out = open('active_active_ftmemberc1.out', 'w')
        ftmemberc2_out = open('active_active_ftmemberc2.out', 'w')

        ret1 = start_app("basicftmemberc",
                         "pub",
                         args=["-g", "active-active1", "-b"],
                         stdout=ftmemberc1_out,
                         stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is active",
                              "active_active_ftmemberc1.out")
        ret3 = start_app("basicftmemberc",
                         "sub",
                         args=["-g", "active-active2", "-b"],
                         stdout=ftmemberc2_out,
                         stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is active",
                              "active_active_ftmemberc2.out")
        ret5 = call_wait4text("Current state is standby",
                              "active_active_ftmemberc1.out")

        ftmemberc1_out.close()
        ftmemberc2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2 == 0)
        self.assertTrue(ret4 == 0)
        self.assertTrue(ret5 == 1)
    def test_ft_priorityc(self):
        '''start two basicftmemberc with different priority and verify that the one with lower priority goes to standby
        from active'''
        my_print(
            "\n-----------------Running basicftmemberc test priority-----------------\n"
        )
        ftmemberc1_out = open('priority_ftmemberc1.out', 'w')
        ftmemberc2_out = open('priority_ftmemberc2.out', 'w')

        ret1 = start_app("basicftmemberc",
                         "pub",
                         args=["-g", "priority", "-w", "40", "-b"],
                         stdout=ftmemberc1_out,
                         stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is active",
                              "priority_ftmemberc1.out")
        ret3 = start_app("basicftmemberc",
                         "sub",
                         args=["-g", "priority", "-w", "60", "-b"],
                         stdout=ftmemberc2_out,
                         stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is active",
                              "priority_ftmemberc2.out")
        ret5 = call_wait4text("Current state is standby",
                              "priority_ftmemberc1.out")

        ftmemberc1_out.close()
        ftmemberc2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2 == 0)
        self.assertTrue(ret4 == 0)
        self.assertTrue(ret5 == 0)
    def test_pubsubc(self):
        '''publish messages using basicpubc and verify basicsubc receives the messages'''
        my_print(
            "\n-------------------------Running pubsubc test-------------------------\n"
        )
        basicsubc_out = open('pubsub_basicsubc.out', 'w')
        basicsubc_err = open('pubsub_basicsubc.err', 'w')
        basicpubc_out = open('pubsub_basicpubc.out', 'w')
        ret1 = start_app("basicsubc",
                         "sub",
                         args=["-v", "-v", "-v", "-v"],
                         stdout=basicsubc_out,
                         stderr=basicsubc_err)

        ret2 = call_wait4text("Created inbound subscription",
                              "pubsub_basicsubc.out")
        ret3 = start_app("basicpubc",
                         "pub",
                         stdout=basicpubc_out,
                         stderr=subprocess.STDOUT)

        ret4 = call_wait4text("EXIT", "pubsub_basicsubc.out")
        ret5 = call_comparelog("pubsub_expectedsubc.out",
                               "pubsub_basicsubc.out")

        basicsubc_out.close()
        basicsubc_err.close()
        basicpubc_out.close()
        if ret1.poll() is None:
            kill_process(ret1.pid)
        if ret3.poll() is None:
            kill_process(ret3.pid)

        self.assertTrue(ret4 == 0)
        self.assertTrue(ret5 == 0)
    def test_req_replyc(self):
        '''Send request from basicinbox and verify it recives reply from basicpub'''
        my_print(
            "\n----------------------Running request_replyc test---------------------\n"
        )
        basicpubc_out = open('req_reply_basicpubc.out', 'w')
        basicpubc_err = open('req_reply_basicpubc.err', 'w')
        basicinboxc_out = open('req_reply_basicinboxc.out', 'w')

        ret1 = start_app("basicpubc",
                         "pub",
                         args=["-v", "-v", "-v", "-v"],
                         stdout=basicpubc_out,
                         stderr=basicpubc_err)
        ret2 = call_wait4text("Created inbound subscription",
                              "req_reply_basicpubc.out")
        ret3 = start_app("basicinboxc",
                         "sub",
                         stdout=basicinboxc_out,
                         stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Received reply", "req_reply_basicinboxc.out")

        basicpubc_out.close()
        basicpubc_err.close()
        basicinboxc_out.close()
        kill_process(ret3.pid)

        self.assertTrue(ret4 == 0)
    def test_req_replyjava(self):
        '''Send request from basicinboxjava and verify it recives reply from basicpubjava'''
        my_print("\n----------Running req_replyjava test----------\n")
        basicpubjava_out = open('req_reply_basicpubjava.out', 'w')
        basicpubjava_err = open('req_reply_basicpubjava.err', 'w')
        basicinboxjava_out = open('req_reply_basicinboxjava.out', 'w')
        ret1 = start_javaapp("BasicPubJava",
                             "pub",
                             args=["-v", "-v", "-v", "-v"],
                             stdout=basicpubjava_out,
                             stderr=basicpubjava_err)
        ret2 = call_wait4text("Created inbound subscription",
                              "req_reply_basicpubcpp.out",
                              args=["-t", '1'])
        ret3 = start_javaapp("BasicInboxJava",
                             "sub",
                             stdout=basicinboxjava_out,
                             stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Received reply", "req_reply_basicinboxjava.out")

        basicpubjava_out.close()
        basicpubjava_err.close()
        basicinboxjava_out.close()
        kill_process(ret3.pid)

        self.assertTrue(ret4 == 0)
    def test_ft_active_standbyc(self):
        '''start two basicftmemberc and verify the first one goes ot active and second to standby, if both belong to same group'''
        my_print(
            "\n--------------Running basicftmemberc test active-standby--------------\n"
        )
        ftmemberc1_out = open('active_standby_ftmemberc1.out', 'w')
        ftmemberc2_out = open('active_standby_ftmemberc2.out', 'w')

        ret1 = start_app("basicftmemberc",
                         "pub",
                         args=["-g", "active-standby", "-b"],
                         stdout=ftmemberc1_out,
                         stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is active",
                              "active_standby_ftmemberc1.out")
        ret3 = start_app("basicftmemberc",
                         "sub",
                         args=["-g", "active-standby", "-b"],
                         stdout=ftmemberc2_out,
                         stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is standby",
                              "active_standby_ftmemberc2.out")
        ret5 = call_wait4text("Current state is standby",
                              "active_standby_ftmemberc1.out")

        ftmemberc1_out.close()
        ftmemberc2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2 == 0)
        self.assertTrue(ret4 == 0)
        self.assertTrue(ret5 == 1)
    def test_ft_priorityjava(self):
        '''start two basicftmemberjava with different priority and verify that the one with lower priority goes to standby
        from active'''
        my_print(
            "\n----------Running basicftmemberjava test priority----------\n")
        ftmemberjava1_out = open('priority_ftmemberjava1.out', 'w')
        ftmemberjava2_out = open('priority_ftmemberjava2.out', 'w')

        ret1 = start_javaapp("BasicFtMemberJava",
                             "pub",
                             args=["-g", "priority", "-w", "40", "-b"],
                             stdout=ftmemberjava1_out,
                             stderr=subprocess.STDOUT)

        ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE",
                              "priority_ftmemberjava1.out")
        ret3 = start_javaapp("BasicFtMemberJava",
                             "sub",
                             args=["-g", "priority", "-w", "60", "-b"],
                             stdout=ftmemberjava2_out,
                             stderr=subprocess.STDOUT)

        ret4 = call_wait4text("Current state is: FT_STATE_ACTIVE",
                              "priority_ftmemberjava2.out")

        ret5 = call_wait4text("Current state is: FT_STATE_STANDBY",
                              "priority_ftmemberjava1.out")
        ftmemberjava1_out.close()
        ftmemberjava2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2 == 0)
        self.assertTrue(ret4 == 0)
        self.assertTrue(ret5 == 0)
    def test_ft_active_activejava(self):
        '''start two basicftmemberjava and verify that both go to active, if they belong to different groups'''
        my_print(
            "\n----------Running basicftmemberjava test active-active----------\n"
        )
        ftmemberjava1_out = open('active_active_ftmemberjava1.out', 'w')
        ftmemberjava2_out = open('active_active_ftmemberjava2.out', 'w')

        ret1 = start_javaapp("BasicFtMemberJava",
                             "pub",
                             args=["-g", "active-active1", "-b"],
                             stdout=ftmemberjava1_out,
                             stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE",
                              "active_active_ftmemberjava1.out")
        ret3 = start_javaapp("BasicFtMemberJava",
                             "sub",
                             args=["-g", "active-active2", "-b"],
                             stdout=ftmemberjava2_out,
                             stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is: FT_STATE_ACTIVE",
                              "active_active_ftmemberjava2.out")
        ret5 = call_wait4text("Current state is: FT_STATE_STANDBY",
                              "active_active_ftmemberjava1.out")

        ftmemberjava1_out.close()
        ftmemberjava2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2 == 0)
        self.assertTrue(ret4 == 0)
        self.assertTrue(ret5 == 1)
    def test_req_replycpp(self):
        '''Send request from basicinboxcpp and verify it recives reply from basicpubcpp'''
        my_print("\n----------Running req_replycpp test----------\n")
        basicpubcpp_out = open('req_reply_basicpubcpp.out','w')
        basicpubcpp_err = open('req_reply_basicpubcpp.err','w')
        basicinboxcpp_out = open('req_reply_basicinboxcpp.out','w')
        ret1 = start_app("basicpubcpp","pub",args=["-v","-v","-v","-v"],stdout=basicpubcpp_out,stderr=basicpubcpp_err) 
        ret2 = call_wait4text("Created inbound subscription","req_reply_basicpubcpp.out",args=["-t",'1'])
        ret3 = start_app("basicinboxcpp","sub",stdout=basicinboxcpp_out,stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Received reply", "req_reply_basicinboxcpp.out")

        basicpubcpp_out.close()
        basicpubcpp_err.close()
        basicinboxcpp_out.close()
        kill_process(ret3.pid)

        self.assertTrue(ret4==0)
    def test_ft_active_standbycpp(self):
        '''start two basicftmembercpp and verify the first one goes to active and second to standby, if both belong to same group'''
        my_print("\n----------Running basicftmembercpp test active-standby----------\n")
        ftmembercpp1_out = open('active_standby_ftmembercpp1.out','w')
        ftmembercpp2_out = open('active_standby_ftmembercpp2.out','w')

        ret1 = start_app("basicftmembercpp","pub",args=["-g","active-standby","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is: active", "active_standby_ftmembercpp1.out")
        ret3 = start_app("basicftmembercpp","sub",args=["-g","active-standby","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is: standby", "active_standby_ftmembercpp2.out")
        ret5 = call_wait4text("Current state is: standby", "active_standby_ftmembercpp1.out")

        ftmembercpp1_out.close()
        ftmembercpp2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)
        
        self.assertTrue(ret2==0)
        self.assertTrue(ret4==0)
        self.assertTrue(ret5==1) 
    def test_ft_active_activejava(self):
        '''start two basicftmemberjava and verify that both go to active, if they belong to different groups'''
        my_print("\n----------Running basicftmemberjava test active-active----------\n")
        ftmemberjava1_out = open('active_active_ftmemberjava1.out','w')
        ftmemberjava2_out = open('active_active_ftmemberjava2.out','w')

        ret1 = start_javaapp("BasicFtMemberJava","pub",args=["-g","active-active1","-b"],stdout=ftmemberjava1_out,stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE", "active_active_ftmemberjava1.out")
        ret3 = start_javaapp("BasicFtMemberJava","sub",args=["-g","active-active2","-b"],stdout=ftmemberjava2_out,stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is: FT_STATE_ACTIVE", "active_active_ftmemberjava2.out")
        ret5 = call_wait4text("Current state is: FT_STATE_STANDBY", "active_active_ftmemberjava1.out")

        ftmemberjava1_out.close()
        ftmemberjava2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2==0)
        self.assertTrue(ret4==0)
        self.assertTrue(ret5==1)
    def test_ft_active_standbyjava(self):
        '''start two basicftmemberjava and verify the first one goes ot active and second to standby, if both belong to same group'''
        my_print("\n----------Running basicftmemberjava test active-standby----------\n")
        ftmemberjava1_out = open('active_standby_ftmemberjava1.out','w')
        ftmemberjava2_out = open('active_standby_ftmemberjava2.out','w')

        ret1 = start_javaapp("BasicFtMemberJava","pub",args=["-g","active-standby","-b"],stdout=ftmemberjava1_out,stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE", "active_standby_ftmemberjava1.out")
        ret3 = start_javaapp("BasicFtMemberJava","sub",args=["-g","active-standby","-b"],stdout=ftmemberjava2_out,stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is: FT_STATE_STANDBY", "active_standby_ftmemberjava2.out")
        ret5 = call_wait4text("Current state is: FT_STATE_STANDBY", "active_standby_ftmemberjava1.out")

        ftmemberjava1_out.close()
        ftmemberjava2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)
  
        self.assertTrue(ret2==0)
        self.assertTrue(ret4==0)
        self.assertTrue(ret5==1)
    def test_ft_prioritycpp(self):
        '''start two basicftmembercpp with different priority and verify that the one with lower priority goes to standby
        from active'''
        my_print("\n----------Running basicftmemberpp test priority----------\n")
        ftmembercpp1_out = open('priority_ftmembercpp1.out','w')
        ftmembercpp2_out = open('priority_ftmembercpp2.out','w')

        ret1 =start_app("basicftmembercpp","pub",args=["-g","priority","-w","40","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is: active", "priority_ftmembercpp1.out")
        ret3 = start_app("basicftmembercpp","sub",args=["-g","priority","-w","60","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is: active", "priority_ftmembercpp2.out")
        ret5 = call_wait4text("Current state is: standby", "priority_ftmembercpp1.out")
        ftmembercpp1_out.close()
        ftmembercpp2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)
        
        self.assertTrue(ret2==0)
        self.assertTrue(ret4==0)
        self.assertTrue(ret5==0)
    def test_ft_active_activecpp(self):
        '''start two basicftmembercpp and verify that both go to active, if they belong to different groups'''
        my_print("\n----------Running basicftmemberpp test active-active----------\n")
        ftmembercpp1_out = open('active_active_ftmembercpp1.out','w')
        ftmembercpp2_out = open('active_active_ftmembercpp2.out','w')


        ret1 = start_app("basicftmembercpp","pub",args=["-g","active-active1","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is: active", "active_active_ftmembercpp1.out")
        ret3 = start_app("basicftmembercpp","sub",args=["-g","active-active2","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is: active", "active_active_ftmembercpp2.out")
        ret5 = call_wait4text("Current state is: standby", "active_active_ftmembercpp1.out")

        ftmembercpp1_out.close()
        ftmembercpp2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2==0)
        self.assertTrue(ret4==0) 
        self.assertTrue(ret5==1)
    def test_ft_standby_to_activejava(self):
        '''Start two basicftmemberjava with same group and stop the active one, verify the standby basicftmemberjava goes to active'''
        my_print("\n----------Running basicftmemberjava test standby-to-active----------\n")
        ftmemberjava1_out = open('standby_to_active_ftmemberjava1.out','w')
        ftmemberjava2_out = open('standby_to_active_ftmemberjava2.out','w')

        ret1 = start_javaapp("BasicFtMemberJava","pub",args=["-g","standby-to-active","-b"],stdout=ftmemberjava1_out,stderr=subprocess.STDOUT)

        ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE", "standby_to_active_ftmemberjava1.out")

        ret3 = start_javaapp("BasicFtMemberJava","sub",args=["-g","standby-to-active","-b"],stdout=ftmemberjava2_out,stderr=subprocess.STDOUT)

        ret4 = call_wait4text("Current state is: FT_STATE_STANDBY", "standby_to_active_ftmemberjava2.out")

        kill_process(ret1.pid)

        ret5 = call_wait4text("Current state is: FT_STATE_ACTIVE", "standby_to_active_ftmemberjava2.out")

        ftmemberjava1_out.close()
        ftmemberjava2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2==0)
        self.assertTrue(ret4==0)
        self.assertTrue(ret5==0)
    def test_ft_priorityjava(self):
        '''start two basicftmemberjava with different priority and verify that the one with lower priority goes to standby
        from active'''
        my_print("\n----------Running basicftmemberjava test priority----------\n")
        ftmemberjava1_out = open('priority_ftmemberjava1.out','w')
        ftmemberjava2_out = open('priority_ftmemberjava2.out','w')

        ret1 =start_javaapp("BasicFtMemberJava","pub",args=["-g","priority","-w","40","-b"],stdout=ftmemberjava1_out,stderr=subprocess.STDOUT)

        ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE", "priority_ftmemberjava1.out")
        ret3 = start_javaapp("BasicFtMemberJava","sub",args=["-g","priority","-w","60","-b"],stdout=ftmemberjava2_out,stderr=subprocess.STDOUT)

        ret4 = call_wait4text("Current state is: FT_STATE_ACTIVE", "priority_ftmemberjava2.out")

        ret5 = call_wait4text("Current state is: FT_STATE_STANDBY", "priority_ftmemberjava1.out")
        ftmemberjava1_out.close()
        ftmemberjava2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2==0)
        self.assertTrue(ret4==0)
        self.assertTrue(ret5==0)
Example #18
0
    def init_yesterday_hk_info(self, cdate):
        succeed = True
        for data in ((ct.SH_MARKET_SYMBOL, ct.HK_MARKET_SYMBOL),
                     (ct.SZ_MARKET_SYMBOL, ct.HK_MARKET_SYMBOL)):
            if not self.connect_client.set_market(data[0], data[1]):
                self.logger.error("connect_client for %s failed" % data)
                succeed = False
                continue

            if not self.connect_client.update(cdate):
                succeed = False

            self.connect_client.close()
            self.connect_client.quit()
        kill_process("zygote")
        kill_process("defunct")
        kill_process("show-component-extension-options")
        return succeed
    def test_ft_standby_to_activejava(self):
        '''Start two basicftmemberjava with same group and stop the active one, verify the standby basicftmemberjava goes to active'''
        my_print(
            "\n----------Running basicftmemberjava test standby-to-active----------\n"
        )
        ftmemberjava1_out = open('standby_to_active_ftmemberjava1.out', 'w')
        ftmemberjava2_out = open('standby_to_active_ftmemberjava2.out', 'w')

        ret1 = start_javaapp("BasicFtMemberJava",
                             "pub",
                             args=["-g", "standby-to-active", "-b"],
                             stdout=ftmemberjava1_out,
                             stderr=subprocess.STDOUT)

        ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE",
                              "standby_to_active_ftmemberjava1.out")

        ret3 = start_javaapp("BasicFtMemberJava",
                             "sub",
                             args=["-g", "standby-to-active", "-b"],
                             stdout=ftmemberjava2_out,
                             stderr=subprocess.STDOUT)

        ret4 = call_wait4text("Current state is: FT_STATE_STANDBY",
                              "standby_to_active_ftmemberjava2.out")

        kill_process(ret1.pid)

        ret5 = call_wait4text("Current state is: FT_STATE_ACTIVE",
                              "standby_to_active_ftmemberjava2.out")

        ftmemberjava1_out.close()
        ftmemberjava2_out.close()
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2 == 0)
        self.assertTrue(ret4 == 0)
        self.assertTrue(ret5 == 0)
    def test_ft_standby_to_activec(self):
        '''Start two basicftmemberc with same group and stop the active one, verify the standby basicftmember goes to active'''
        my_print("\n-------------Running basicftmemberc test standby-to-active------------\n")
        ftmemberc1_out = open('standby_to_active_ftmemberc1.out','w')
        ftmemberc2_out = open('standby_to_active_ftmemberc2.out','w')

        ret1 = start_app("basicftmemberc","pub",args=["-g","standby-to-active","-b"],stdout=ftmemberc1_out,stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is active", "standby_to_active_ftmemberc1.out")
        ret3 = start_app("basicftmemberc","sub",args=["-g","standby-to-active","-b"],stdout=ftmemberc2_out,stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is standby", "standby_to_active_ftmemberc2.out")
        kill_process(ret1.pid)
        
        ret5 = call_wait4text("Current state is active", "standby_to_active_ftmemberc2.out")

        ftmemberc1_out.close()
        ftmemberc2_out.close()
        
        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2==0)
        self.assertTrue(ret4==0)
        self.assertTrue(ret5==0)
    def test_ft_standby_to_activecpp(self):
        '''Start two basicftmembercpp with same group and stop the active one, verify the standby basicftmemberpp goes to active'''
        my_print(
            "\n----------Running basicftmemberpp test standby-to-active----------\n"
        )
        ftmembercpp1_out = open('standby_to_active_ftmembercpp1.out', 'w')
        ftmembercpp2_out = open('standby_to_active_ftmembercpp2.out', 'w')

        ret1 = start_app("basicftmembercpp",
                         "pub",
                         args=["-g", "standby-to-active", "-b"],
                         stdout=ftmembercpp1_out,
                         stderr=subprocess.STDOUT)
        ret2 = call_wait4text("Current state is: active",
                              "standby_to_active_ftmembercpp1.out")
        ret3 = start_app("basicftmembercpp",
                         "sub",
                         args=["-g", "standby-to-active", "-b"],
                         stdout=ftmembercpp2_out,
                         stderr=subprocess.STDOUT)
        ret4 = call_wait4text("Current state is: standby",
                              "standby_to_active_ftmembercpp2.out")

        kill_process(ret1.pid)

        ret5 = call_wait4text("Current state is: active",
                              "standby_to_active_ftmembercpp2.out")

        ftmembercpp1_out.close()
        ftmembercpp2_out.close()

        kill_process(ret1.pid)
        kill_process(ret3.pid)

        self.assertTrue(ret2 == 0)
        self.assertTrue(ret4 == 0)
        self.assertTrue(ret5 == 0)
Example #22
0
 def clear_network_env(self):
     kill_process("google-chrome")
     kill_process("renderer")
     kill_process("Xvfb")
     kill_process("zygote")
     kill_process("defunct")
     kill_process("show-component-extension-options")
from common import kill_process
import os
import time


class contacts_fps(test_fps):
    def load_resource(self):
        self.logout(self.my_func_name(), "...")
        os.system("adb -s %s push ./res/Contacts/Contacts_100.vcf /sdcard/" %
                  self.dev_sn)

    def measure(self):
        self.logout(self.my_func_name(), "...")
        if self.device(text="Import contacts").exists:
            self.locate("Import contacts", self.DIR_NONE)
            self.locate("Import from storage", self.DIR_NONE)
        time.sleep(3)
        self.icon_click()
        self.swipe_vert(5, self.SWIPE_DIR_UP)
        #self.swipe_vert(5,self.SWIPE_DIR_DOWN)
        self.icon_click()


if __name__ == "__main__":
    os.system("adb -s %s root" % dev_sn)
    kill_process(dev_sn, "native_agent")
    np_contacts = ["Contacts", "", "com.android.contacts"]
    contacts_fps_test = contacts_fps(dev_sn, np_contacts)
    contacts_fps_test.exec_test()
    print("result of contacts_fps_test is %sfps" % contacts_fps_test.result)
from test import test_fps 
from common import dev_sn
from common import kill_process
import os
import time

class homescreen_fps(test_fps):
    def measure(self):
        self.logout(self.my_func_name(),"...")
        time.sleep(3)
        self.icon_click()
        self.swipe_horiz(3,self.SWIPE_DIR_LEFT)
        self.swipe_horiz(3,self.SWIPE_DIR_RIGHT)
        self.device(description='Apps').click()
        self.swipe_horiz(5,self.SWIPE_DIR_LEFT)
        self.swipe_horiz(5,self.SWIPE_DIR_RIGHT)
        self.icon_click()

if __name__=="__main__": 
    os.system("adb -s %s root"%dev_sn)
    kill_process(dev_sn,"native_agent")
    np_homescreen = ["Launcher","","com.android.launcher"]
    homescreen_fps_test = homescreen_fps(dev_sn,np_homescreen)
    homescreen_fps_test.exec_test()
    print("result of homescreen_fps_test is %sfps"%homescreen_fps_test.result)
Example #25
0
 def update(self, sleep_time):
     while True:
         self.logger.info("enter daily update process. %s" %
                          datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
         try:
             if self.cal_client.is_trading_day():
                 self.logger.info(
                     "is trading day. %s" %
                     datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
                 if self.is_collecting_time():
                     self.logger.info(
                         "is collecting time. %s" %
                         datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
                     self.bootstrap(
                         cdate=datetime.now().strftime('%Y-%m-%d'))
         except Exception as e:
             kill_process("google-chrome")
             kill_process("renderer")
             kill_process("Xvfb")
             kill_process("zygote")
             kill_process("defunct")
             kill_process("show-component-extension-options")
             self.logger.error(e)
         time.sleep(sleep_time)
Example #26
0

if __name__ == '__main__':
    #from cmysql import CMySQL
    #mysql_client = CMySQL(dbinfo = ct.DB_INFO)
    #mysql_client.delete_db(ct.RINDEX_STOCK_INFO_DB)
    #mysql_client.delete_db(ct.RINDEX_INDUSTRY_INFO_DB)
    #for code in IndustryInfo().get().code.tolist():
    #    print(code)
    #    mysql_client.delete_db('i%s' % code)
    #for code in CStockInfo().get().code.tolist():
    #    print(code)
    #    mysql_client.delete_db('s%s' % code)
    #import sys
    #sys.exit(0)

    kill_process("google-chrome")
    kill_process("renderer")
    kill_process("Xvfb")
    kill_process("zygote")
    kill_process("defunct")
    kill_process("show-component-extension-options")

    dm = DataManager()
    dm.logger.info("start compute!")
    #dm.init_stock_info(cdate = None)
    #dm.init_base_float_profit()
    #dm.bootstrap(exec_date = '2019-01-18')
    dm.bootstrap(cdate='2019-01-18', exec_date='2019-01-18')
    dm.logger.info("end compute!")