1 /******************************************************************************
2 * Copyright (c) 2000-2016 Ericsson Telecom AB
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
13 ******************************************************************************/
15 #include "org_eclipse_titan_executor_jni_JNIMiddleWare.h"
16 #include <sys/socket.h>
17 #include <netinet/in.h>
18 #include <arpa/inet.h>
19 #include "../core/Textbuf.hh"
20 #include "../common/memory.h"
21 #include "../common/license.h"
22 #include "../common/version.h"
27 using mctr::MainController
;
28 using namespace jnimw
;
30 JNIEXPORT jlong JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_init(JNIEnv
*, jobject
, jint max_ptcs
)
33 userInterface
= new Jnimw();
34 Jnimw::userInterface
= userInterface
;
35 MainController::initialize(*userInterface
, (int)max_ptcs
);
36 return (jlong
)userInterface
;
39 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_terminate(JNIEnv
*, jobject
)
41 MainController::terminate();
42 delete Jnimw::userInterface
;
43 Jnimw::userInterface
= NULL
;
46 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_add_1host(JNIEnv
*env
, jobject
, jstring group_name
, jstring host_name
)
48 // Fix for TR HO56282.
49 if (!Jnimw::userInterface
)
53 const char *grp_name
= env
->GetStringUTFChars(group_name
, &iscopy_grp
);
54 const char *hst_name
= env
->GetStringUTFChars(host_name
, &iscopy_hst
);
55 MainController::add_host(grp_name
, hst_name
);
56 env
->ReleaseStringUTFChars(group_name
, grp_name
);
57 env
->ReleaseStringUTFChars(host_name
, hst_name
);
60 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_assign_1component(JNIEnv
*env
, jobject
, jstring host_or_group
, jstring component_id
)
62 // Fix for TR HO56282.
63 if (!Jnimw::userInterface
)
67 const char *hog
= env
->GetStringUTFChars(host_or_group
, &iscopy_hog
);
68 const char *cid
= env
->GetStringUTFChars(component_id
, &iscopy_cid
);
69 MainController::assign_component(hog
, cid
);
70 env
->ReleaseStringUTFChars(host_or_group
, hog
);
71 env
->ReleaseStringUTFChars(component_id
, cid
);
74 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_destroy_1host_1groups(JNIEnv
*, jobject
)
76 // Fix for TR HO56282.
77 if (!Jnimw::userInterface
)
79 MainController::destroy_host_groups();
82 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_set_1kill_1timer(JNIEnv
*, jobject
, jdouble timer_val
)
84 // Fix for TR HO56282.
85 if (!Jnimw::userInterface
)
87 MainController::set_kill_timer((double)timer_val
);
90 JNIEXPORT jint JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_start_1session(JNIEnv
*env
, jobject
, jstring local_address
, jint tcp_port
, jboolean unixdomainsocketenabled
)
92 // Fix for TR HO56282.
93 if (!Jnimw::userInterface
)
96 const char *local_addr
= env
->GetStringUTFChars(local_address
, &iscopy
);
97 if (strcmp(local_addr
, "NULL") == 0) {
98 env
->ReleaseStringUTFChars(local_address
, local_addr
);
101 unsigned short tcp_listen_port
= (unsigned short)tcp_port
;
102 int ret
= MainController::start_session(local_addr
, tcp_listen_port
, unixdomainsocketenabled
);
103 if (local_addr
!= NULL
) env
->ReleaseStringUTFChars(local_address
, local_addr
);
107 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_shutdown_1session(JNIEnv
*, jobject
)
109 // Fix for TR HO56282.
110 if (!Jnimw::userInterface
)
112 MainController::shutdown_session();
117 * Configure MainController and HCs.
118 * It is also known as "Set parameter" operation.
120 * It can be called in the following states:
121 * MC_LISTENING -> MC_LISTENING_CONFIGURED will be the next state, when configuring operation is finished
122 * MC_LISTENING_CONFIGURED -> MC_LISTENING_CONFIGURED will be the next state, when configuring operation is finished
123 * MC_HC_CONNECTED -> MC_CONFIGURING immediately and MC_ACTIVE when configuring operation is finished
125 * @param env Pointer to the caller java environment (mandatory parameter of every JNI function)
126 * @param jobject The caller java object (mandatory parameter of every JNI function)
127 * @param config_file config string, generated from the config file by removing unnecessary parts. It can be empty string, and also null.
128 * Generating config string can be done in 2 ways:
129 * by "hand" (if the parameter is not empty string and not null):
130 * on the java side, and pass it as a parameter, for an example see JniExecutor.DEFAULT_CONFIG_STRING or BaseExecutor.generateCfgString()
131 * by MainController (if the parameter is empty string or null):
132 * call set_cfg_file() after init() with the cfg file, and let MainController process it and create the config string,
133 * and then config() can be called with empty string or null as a parameter, which means that config string from MainController config data will be used.
135 * NOTE: Function comment is here, because function declaration is in org_eclipse_titan_executor_jni_JNIMiddleWare.h, which is generated.
137 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_configure(JNIEnv
*env
, jobject
, jstring config_file
)
139 // Fix for TR HO56282.
140 if (!Jnimw::userInterface
)
143 if (config_file
== NULL
|| env
->GetStringLength( config_file
) == 0 ) {
144 // use config string, which was generated by MainController
145 MainController::configure(Jnimw::mycfg
.config_read_buffer
);
148 const char *conf_file
= env
->GetStringUTFChars(config_file
, &iscopy
);
149 MainController::configure(conf_file
);
150 env
->ReleaseStringUTFChars(config_file
, conf_file
);
155 * The name of the config file is sent here for syntactic and semantic analysis.
156 * The result config string is needed by start_session() and configure().
157 * Result is stored in Jnimw::mycfg.
158 * We need the following info from it:
159 * config_read_buffer: passed to configure() if parameter is an empty string
160 * local_address: needed by the java side for start_session() and starting the HC, it is read by calling get_mc_host()
161 * tcp_listen_port: needed by the java side for start_session(), it is read by calling get_port()
162 * kill_timer: processed in this function
163 * group_list: processed in this function
164 * component_list: processed in this function
165 * This code is based on the following code: Cli.cc: Cli::enterloop()
167 * @param env Pointer to the caller java environment (mandatory parameter of every JNI function)
168 * @param jobject The caller java object (mandatory parameter of every JNI function)
169 * @param conf_file_name The configuration file name of the TTCN-3 test project
171 * NOTE: Function comment is here, because function declaration is in org_eclipse_titan_executor_jni_JNIMiddleWare.h, which is generated.
173 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_set_1cfg_1file(JNIEnv
*env
, jobject
, jstring config_file_name
)
175 if (!Jnimw::userInterface
)
178 if (config_file_name
== NULL
)
180 const char *conf_file_name
= env
->GetStringUTFChars(config_file_name
, &iscopy
);
182 if (process_config_read_file(conf_file_name
, &Jnimw::mycfg
)) {
183 MainController::error("Error was found in the configuration file. Exiting.");
186 MainController::set_kill_timer(Jnimw::mycfg
.kill_timer
);
188 for (int i
= 0; i
< Jnimw::mycfg
.group_list_len
; ++i
) {
189 const group_item
& item
= Jnimw::mycfg
.group_list
[i
];
190 MainController::add_host( item
.group_name
, item
.host_name
);
193 for (int i
= 0; i
< Jnimw::mycfg
.component_list_len
; ++i
) {
194 const component_item
& item
= Jnimw::mycfg
.component_list
[i
];
195 MainController::assign_component( item
.host_or_group
, item
.component
);
199 env
->ReleaseStringUTFChars(config_file_name
, conf_file_name
);
203 * Local host address for start_session() and starting the HC
204 * This will contain valid information after successful run of Java_org_eclipse_titan_executor_jni_JNIMiddleWare_set_1cfg_1file()
206 * @param env Pointer to the caller java environment (mandatory parameter of every JNI function)
207 * @param jobject The caller java object (mandatory parameter of every JNI function)
208 * @return Local host address
210 * NOTE: Function comment is here, because function declaration is in org_eclipse_titan_executor_jni_JNIMiddleWare.h, which is generated.
212 JNIEXPORT jstring JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1mc_1host(JNIEnv
*env
, jobject
)
214 return env
->NewStringUTF( Jnimw::mycfg
.local_addr
!= NULL
? Jnimw::mycfg
.local_addr
: "NULL" );
218 * TCP listen port for start_session()
219 * This will contain valid information after successful run of Java_org_eclipse_titan_executor_jni_JNIMiddleWare_set_1cfg_1file()
221 * @param env Pointer to the caller java environment (mandatory parameter of every JNI function)
222 * @param jobject The caller java object (mandatory parameter of every JNI function)
223 * @return TCP listen port
225 * NOTE: Function comment is here, because function declaration is in org_eclipse_titan_executor_jni_JNIMiddleWare.h, which is generated.
227 JNIEXPORT jint JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1port(JNIEnv
*, jobject
)
229 return (jint
)Jnimw::mycfg
.tcp_listen_port
;
232 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_create_1mtc(JNIEnv
*, jobject
, jint host_index
)
234 // Fix for TR HO56282.
235 if (!Jnimw::userInterface
)
237 MainController::create_mtc((int)host_index
);
240 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_exit_1mtc(JNIEnv
*, jobject
)
242 // Fix for TR HO56282.
243 if (!Jnimw::userInterface
)
245 MainController::exit_mtc();
248 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_execute_1control(JNIEnv
*env
, jobject
, jstring module_name
)
250 // Fix for TR HO56282.
251 if (!Jnimw::userInterface
)
254 const char *mod_name
= env
->GetStringUTFChars(module_name
, &iscopy
);
255 MainController::execute_control(mod_name
);
256 env
->ReleaseStringUTFChars(module_name
, mod_name
);
259 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_execute_1testcase(JNIEnv
*env
, jobject
, jstring module_name
, jstring testcase_name
)
261 // Fix for TR HO56282.
262 if (!Jnimw::userInterface
)
266 const char *mod_name
= env
->GetStringUTFChars(module_name
, &iscopy_mod
);
267 const char *testc_name
= env
->GetStringUTFChars(testcase_name
, &iscopy_tes
);
268 MainController::execute_testcase(mod_name
, testc_name
);
269 env
->ReleaseStringUTFChars(module_name
, mod_name
);
270 env
->ReleaseStringUTFChars(testcase_name
, testc_name
);
274 * Gets the length of the execute list.
275 * @param env Pointer to the caller java environment (mandatory parameter of every JNI function)
276 * @param jobject The caller java object (mandatory parameter of every JNI function)
277 * @return The length of the execute list,
278 * which is defined in the [EXECUTE] section in the configuration file.
279 * 0, if there is no [EXECUTE] section in the configuration file.
281 * NOTE: Function comment is here, because function declaration is in org_eclipse_titan_executor_jni_JNIMiddleWare.h, which is generated.
283 JNIEXPORT jint JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1execute_1cfg_1len(JNIEnv
*env
, jobject
)
285 return (jint
)Jnimw::mycfg
.execute_list_len
;
289 * Executes the index-th element form the execute list,
290 * which is defined in the [EXECUTE] section in the configuration file.
291 * Based on Cli::executeFromList()
292 * @param env Pointer to the caller java environment (mandatory parameter of every JNI function)
293 * @param jobject The caller java object (mandatory parameter of every JNI function)
294 * @param index The test index from the execute list
296 * NOTE: Function comment is here, because function declaration is in org_eclipse_titan_executor_jni_JNIMiddleWare.h, which is generated.
298 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_execute_1cfg(JNIEnv
*env
, jobject
, jint index
)
300 if (!Jnimw::userInterface
)
302 if ( index
< 0 || index
>= Jnimw::mycfg
.execute_list_len
) {
303 MainController::error("Java_org_eclipse_titan_executor_jni_JNIMiddleWare_execute_1cfg(): invalid argument: index");
306 const execute_list_item
& item
= Jnimw::mycfg
.execute_list
[ index
];
307 if ( item
.testcase_name
== NULL
) {
308 MainController::execute_control( item
.module_name
);
309 } else if ( !strcmp( item
.testcase_name
, "*" ) ) {
310 MainController::execute_testcase( item
.module_name
, NULL
);
312 MainController::execute_testcase( item
.module_name
, item
.testcase_name
);
316 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_stop_1after_1testcase(JNIEnv
*, jobject
, jboolean new_state
)
318 // Fix for TR HO56282.
319 if (!Jnimw::userInterface
)
321 MainController::stop_after_testcase((bool)new_state
);
324 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_continue_1testcase(JNIEnv
*, jobject
)
326 // Fix for TR HO56282.
327 if (!Jnimw::userInterface
)
329 MainController::continue_testcase();
332 JNIEXPORT
void JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_stop_1execution(JNIEnv
*, jobject
)
334 // Fix for TR HO56282.
335 if (!Jnimw::userInterface
)
337 MainController::stop_execution();
340 JNIEXPORT jobject JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1state(JNIEnv
*env
, jobject
)
342 jclass cls
= env
->FindClass("org/eclipse/titan/executor/jni/McStateEnum");
344 printf("Can't find class org.eclipse.titan.executor.jni.McStateEnum\n");
348 // Fix for TR HO56282.
349 // MC's get_state() calls lock(), but the mutex is destroyed already at this
350 // point from JNI code...
351 if (!Jnimw::userInterface
) {
352 fid
= env
->GetStaticFieldID(cls
, "MC_INACTIVE",
353 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
355 printf("Can't find field MC_INACTIVE\n");
358 switch (MainController::get_state()) {
359 case mctr::MC_INACTIVE
:
360 fid
= env
->GetStaticFieldID(cls
, "MC_INACTIVE",
361 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
363 printf("Can't find field MC_INACTIVE\n");
366 case mctr::MC_LISTENING
:
367 fid
= env
->GetStaticFieldID(cls
, "MC_LISTENING",
368 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
370 printf("Can't find field MC_LISTENING\n");
373 case mctr::MC_LISTENING_CONFIGURED
:
374 fid
= env
->GetStaticFieldID(cls
, "MC_LISTENING_CONFIGURED",
375 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
377 printf("Can't find field MC_LISTENING_CONFIGURED\n");
380 case mctr::MC_HC_CONNECTED
:
381 fid
= env
->GetStaticFieldID(cls
, "MC_HC_CONNECTED",
382 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
384 printf("Can't find field MC_HC_CONNECTED\n");
387 case mctr::MC_CONFIGURING
:
388 fid
= env
->GetStaticFieldID(cls
, "MC_CONFIGURING",
389 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
391 printf("Can't find field MC_CONFIGURING\n");
394 case mctr::MC_ACTIVE
:
395 fid
= env
->GetStaticFieldID(cls
, "MC_ACTIVE",
396 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
398 printf("Can't find field MC_ACTIVE\n");
401 case mctr::MC_SHUTDOWN
:
402 fid
= env
->GetStaticFieldID(cls
, "MC_SHUTDOWN",
403 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
405 printf("Can't find field MC_SHUTDOWN\n");
408 case mctr::MC_CREATING_MTC
:
409 fid
= env
->GetStaticFieldID(cls
, "MC_CREATING_MTC",
410 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
412 printf("Can't find field MC_CREATING_MTC\n");
416 fid
= env
->GetStaticFieldID(cls
, "MC_READY",
417 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
419 printf("Can't find field MC_READY\n");
422 case mctr::MC_TERMINATING_MTC
:
423 fid
= env
->GetStaticFieldID(cls
, "MC_TERMINATING_MTC",
424 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
426 printf("Can't find field MC_TERMINATING_MTC\n");
429 case mctr::MC_EXECUTING_CONTROL
:
430 fid
= env
->GetStaticFieldID(cls
, "MC_EXECUTING_CONTROL",
431 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
433 printf("Can't find field MC_EXECUTING_CONTROL\n");
436 case mctr::MC_EXECUTING_TESTCASE
:
437 fid
= env
->GetStaticFieldID(cls
, "MC_EXECUTING_TESTCASE",
438 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
440 printf("Can't find field MC_EXECUTING_TESTCASE\n");
443 case mctr::MC_TERMINATING_TESTCASE
:
444 fid
= env
->GetStaticFieldID(cls
, "MC_TERMINATING_TESTCASE",
445 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
447 printf("Can't find field MC_TERMINATING_TESTCASE\n");
450 case mctr::MC_PAUSED
:
451 fid
= env
->GetStaticFieldID(cls
, "MC_PAUSED",
452 "Lorg/eclipse/titan/executor/jni/McStateEnum;");
454 printf("Can't find field MC_PAUSED\n");
458 printf("Unknown mc_state_enum state\n");
461 ret
= env
->GetStaticObjectField(cls
, fid
);
462 env
->ExceptionClear();
466 JNIEXPORT jboolean JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1stop_1after_1testcase(JNIEnv
*, jobject
)
468 // Fix for TR HO56282.
469 if (!Jnimw::userInterface
)
470 return (jboolean
)true;
471 return (jboolean
)MainController::get_stop_after_testcase();
474 JNIEXPORT jint JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1nof_1hosts(JNIEnv
*, jobject
)
476 // Fix for TR HO56282.
477 if (!Jnimw::userInterface
)
479 return (jint
)MainController::get_nof_hosts();
482 JNIEXPORT jobject JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1host_1data(JNIEnv
*env
, jobject
, jint host_index
)
484 // Fix for TR HO56282.
485 if (!Jnimw::userInterface
)
487 mctr::host_struct
*hs
= MainController::get_host_data((int)host_index
);
488 if (hs
== NULL
) return NULL
;
489 IPAddress
*ip_addr
= hs
->ip_addr
;
490 const char *hostname
= hs
->hostname
;
491 const char *hostname_local
= hs
->hostname_local
;
492 const char *machine_type
= hs
->machine_type
;
493 const char *system_name
= hs
->system_name
;
494 const char *system_release
= hs
->system_release
;
495 const char *system_version
= hs
->system_version
;
496 boolean
*transport_supported
= hs
->transport_supported
;
497 const char *log_source
= hs
->log_source
;
498 mctr::hc_state_enum hc_state
= hs
->hc_state
;
499 int hc_fd
= hs
->hc_fd
;
500 Text_Buf
*text_buf
= hs
->text_buf
;
501 int n_components
= hs
->n_components
;
502 component
*components
= hs
->components
;
503 mctr::string_set allowed_components
= hs
->allowed_components
;
504 bool all_components_allowed
= hs
->all_components_allowed
;
505 int n_active_components
= hs
->n_active_components
;
507 /*// --- DEBUG --- filling test data
510 in_addr ip_addr = t_i;
511 const char *hostname = "test hostname";
512 const char *hostname_local = "test hostname_local";
513 const char *machine_type = "test machine_type";
514 const char *system_name = "test system_name";
515 const char *system_release = "test system_release";
516 const char *system_version = "test system_version";
517 boolean test[3] = {true, true, false};
518 boolean *transport_supported = test;
519 const char *log_source = "test log_source";
520 mctr::hc_state_enum hc_state = mctr::HC_CONFIGURING;
522 Text_Buf *text_buf = new Text_Buf();
523 text_buf->push_string("test Text_Buf");
524 int n_components = 3;
525 int test_i[3] = {2,4,5};
526 component *components = (component*) test_i;
527 mctr::string_set s_set;
528 s_set.n_elements = 3;
529 char *t_stringarray[3] = {"test 1", "test 2", "test 3"};
530 s_set.elements = t_stringarray;
531 mctr::string_set allowed_components = s_set;
532 bool all_components_allowed = true;
533 int n_active_components = 5;
534 // --- END OF DEBUG ---*/
536 // creating HostStruct
537 jclass cls
= env
->FindClass("org/eclipse/titan/executor/jni/HostStruct");
539 printf("Can't find class org.eclipse.titan.executor.jni.HostStruct\n");
544 mid
= env
->GetMethodID(cls
, "<init>", "(IIII)V");
545 HostStruct
= env
->NewObject(cls
, mid
, 3, text_buf
->get_len(), n_components
, allowed_components
.n_elements
);
547 // processing struct fields
549 const char *ipaddr
= ip_addr
->get_addr_str();
550 fid
= env
->GetFieldID(cls
, "ip_addr", "Ljava/lang/String;");
552 printf("Can't find field hostname\n");
554 env
->SetObjectField(HostStruct
, fid
, env
->NewStringUTF(ipaddr
));
557 fid
= env
->GetFieldID(cls
, "hostname", "Ljava/lang/String;");
559 printf("Can't find field hostname\n");
561 env
->SetObjectField(HostStruct
, fid
, env
->NewStringUTF(hostname
));
564 fid
= env
->GetFieldID(cls
, "hostname_local", "Ljava/lang/String;");
566 printf("Can't find field hostname_local\n");
568 env
->SetObjectField(HostStruct
, fid
, env
->NewStringUTF(hostname_local
));
571 fid
= env
->GetFieldID(cls
, "machine_type", "Ljava/lang/String;");
573 printf("Can't find field machine_type\n");
575 env
->SetObjectField(HostStruct
, fid
, env
->NewStringUTF(machine_type
));
578 fid
= env
->GetFieldID(cls
, "system_name", "Ljava/lang/String;");
580 printf("Can't find field system_name\n");
582 env
->SetObjectField(HostStruct
, fid
, env
->NewStringUTF(system_name
));
585 fid
= env
->GetFieldID(cls
, "system_release", "Ljava/lang/String;");
587 printf("Can't find field system_release\n");
589 env
->SetObjectField(HostStruct
, fid
, env
->NewStringUTF(system_release
));
592 fid
= env
->GetFieldID(cls
, "system_version", "Ljava/lang/String;");
594 printf("Can't find field system_version\n");
596 env
->SetObjectField(HostStruct
, fid
, env
->NewStringUTF(system_version
));
598 // transport_supported
599 fid
= env
->GetFieldID(cls
, "transport_supported", "[Z");
601 printf("Can't find field transport_supported\n");
603 jbooleanArray TransportSupported
= (jbooleanArray
)env
->GetObjectField(HostStruct
, fid
);
604 env
->SetBooleanArrayRegion(TransportSupported
, (jsize
)0, 3,(jboolean
*)transport_supported
);
607 fid
= env
->GetFieldID(cls
, "log_source", "Ljava/lang/String;");
609 printf("Can't find field log_source\n");
611 env
->SetObjectField(HostStruct
, fid
, env
->NewStringUTF(log_source
));
614 fid
= env
->GetFieldID(cls
, "hc_state", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
616 printf("Can't find field hc_state\n");
619 jclass cls_hc
= env
->FindClass("org/eclipse/titan/executor/jni/HcStateEnum");
620 if( cls_hc
== NULL
) {
621 printf("Can't find class org.eclipse.titan.executor.jni.HcStateEnum\n");
627 fid_hc
= env
->GetStaticFieldID(cls_hc
, "HC_IDLE", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
629 printf("Can't find field HC_IDLE\n");
632 case mctr::HC_CONFIGURING
:
633 fid_hc
= env
->GetStaticFieldID(cls_hc
, "HC_CONFIGURING", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
635 printf("Can't find field HC_CONFIGURING\n");
638 case mctr::HC_ACTIVE
:
639 fid_hc
= env
->GetStaticFieldID(cls_hc
, "HC_ACTIVE", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
641 printf("Can't find field HC_ACTIVE\n");
644 case mctr::HC_OVERLOADED
:
645 fid_hc
= env
->GetStaticFieldID(cls_hc
, "HC_OVERLOADED", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
647 printf("Can't find field HC_OVERLOADED\n");
650 case mctr::HC_CONFIGURING_OVERLOADED
:
651 fid_hc
= env
->GetStaticFieldID(cls_hc
, "HC_CONFIGURING_OVERLOADED", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
653 printf("Can't find field HC_CONFIGURING_OVERLOADED\n");
656 // ----------------------------------------------- 6-7
657 case mctr::HC_EXITING
:
658 fid_hc
= env
->GetStaticFieldID(cls_hc
, "HC_EXITING", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
660 printf("Can't find field HC_EXITING\n");
664 fid_hc
= env
->GetStaticFieldID(cls_hc
, "HC_DOWN", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
666 printf("Can't find field HC_DOWN\n");
670 printf("Unknown hc_state_enum state\n");
672 ret
= env
->GetStaticObjectField(cls_hc
, fid_hc
);
673 env
->ExceptionClear();
674 env
->SetObjectField(HostStruct
, fid
, ret
);
677 fid
= env
->GetFieldID(cls
, "hc_fd", "I");
679 printf("Can't find field hc_fd\n");
681 env
->SetIntField(HostStruct
, fid
, (jint
)hc_fd
);
684 fid
= env
->GetFieldID(cls
, "text_buf", "[B");
686 printf("Can't find field text_buf\n");
688 jbyteArray TextBuf
= (jbyteArray
)env
->GetObjectField(HostStruct
, fid
);
689 env
->SetByteArrayRegion(TextBuf
, (jsize
)0, text_buf
->get_len(),
690 const_cast<jbyte
*>((const jbyte
*)text_buf
->get_data()));
693 fid
= env
->GetFieldID(cls
, "components", "[I");
695 printf("Can't find field components\n");
698 jintArray Components
= (jintArray
)env
->GetObjectField(HostStruct
, fid
);
699 env
->SetIntArrayRegion(Components
, (jsize
)0,n_components
,(jint
*)components
);
701 // allowed_components
702 fid
= env
->GetFieldID(cls
, "allowed_components", "[Ljava/lang/String;");
704 printf("Can't find field allowed_components\n");
706 jobjectArray allowedComponents
= (jobjectArray
) env
->GetObjectField(HostStruct
, fid
);
707 for(int i
= 0; i
< allowed_components
.n_elements
; i
++) {
708 env
->SetObjectArrayElement(allowedComponents
, i
, env
->NewStringUTF(allowed_components
.elements
[i
]));
711 // all_components_allowed
712 fid
= env
->GetFieldID(cls
, "all_components_allowed", "Z");
714 printf("Can't find field all_components_allowed\n");
716 env
->SetBooleanField(HostStruct
, fid
, (jboolean
)all_components_allowed
);
718 // n_active_components
719 fid
= env
->GetFieldID(cls
, "n_active_components", "I");
721 printf("Can't find field n_active_components\n");
723 env
->SetIntField(HostStruct
, fid
, (jint
)n_active_components
);
728 JNIEXPORT jobject JNICALL
Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1component_1data(JNIEnv
*env
, jobject
, jint component_reference
)
730 // Fix for TR HO56282.
731 if (!Jnimw::userInterface
)
733 mctr::component_struct
*cs
= MainController::get_component_data((int)component_reference
);
734 if (cs
== NULL
) return NULL
;
736 // getting data from struct
738 // If any of the pointers are NULL, we return null.
739 // Some of the pointers may be NULL if its value is not initialized,
740 // or temporarily set to NULL, like text_buf is NULL during the create MTC operation: it is set to NULL when create_mtc() is called,
741 // and it will have valid data when asynchronous request of MTC creation is finished.
742 // Reading component data makes sense only in the following states:
743 // MC_READY, MC_EXECUTING_CONTROL, MC_EXECUTING_TESTCASE, MC_TERMINATING_TESTCASE, MC_PAUSED
744 component comp_ref
= cs
->comp_ref
;
745 qualified_name comp_type
= cs
->comp_type
;
746 const char *comp_name
= cs
->comp_name
;
747 if ( NULL
== comp_name
) {
750 const char *log_source
= cs
->log_source
;
751 if ( NULL
== log_source
) {
754 mctr::host_struct
*comp_location
= cs
->comp_location
;
755 if ( NULL
== comp_location
) {
758 mctr::tc_state_enum tc_state
= cs
->tc_state
;
759 verdicttype local_verdict
= cs
->local_verdict
;
760 int tc_fd
= cs
->tc_fd
;
761 Text_Buf
*text_buf
= cs
->text_buf
;
762 if ( NULL
== text_buf
) {
765 qualified_name tc_fn_name
= cs
->tc_fn_name
;
766 const char *return_type
= cs
->return_type
;
767 if ( NULL
== return_type
) {
770 int return_value_len
= cs
->return_value_len
;
771 bool is_alive
= cs
->is_alive
;
772 bool stop_requested
= cs
->stop_requested
;
773 bool process_killed
= cs
->process_killed
;
775 /*// --- DEBUG --- filling test data
776 component comp_ref = (component) 5;
777 qualified_name comp_type;
778 comp_type.module_name = "test module";
779 comp_type.definition_name = "test definition";
780 const char *comp_name = "test comp_name";
781 const char *log_source = "test log_source";
782 // --- DEBUG --- filling inner host_struct
783 mctr::host_struct debug_comp_location;
786 debug_comp_location.ip_addr = t_i;
787 debug_comp_location.hostname = "inner test hostname";
788 debug_comp_location.hostname_local = "inner test hostname_local";
789 debug_comp_location.machine_type = "inner test machine_type";
790 debug_comp_location.system_name = "inner test system_name";
791 debug_comp_location.system_release = "inner test system_release";
792 debug_comp_location.system_version = "inner test system_version";
793 boolean test[3] = {true, true, false};
794 debug_comp_location.transport_supported = test;
795 debug_comp_location.log_source = "inner test log_source";
796 debug_comp_location.hc_state = mctr::HC_CONFIGURING;
797 debug_comp_location.hc_fd = 8;
798 debug_comp_location.text_buf = new Text_Buf();
799 debug_comp_location.text_buf->push_string("inner test Text_Buf");
800 debug_comp_location.n_components = 3;
801 int test_i[3] = {2,4,5};
802 debug_comp_location.components = (component*) test_i;
803 mctr::string_set s_set;
804 s_set.n_elements = 3;
805 char *t_stringarray[3] = {"inner test 1", "inner test 2", "inner test 3"};
806 s_set.elements = t_stringarray;
807 debug_comp_location.allowed_components = s_set;
808 debug_comp_location.all_components_allowed = true;
809 debug_comp_location.n_active_components = 5;
810 // --- END OF DEBUG host_struct ---
811 mctr::host_struct *comp_location = &debug_comp_location;
812 mctr::tc_state_enum tc_state = mctr::TC_INITIAL;
813 verdicttype local_verdict = FAIL;
815 Text_Buf *text_buf = new Text_Buf();
816 text_buf->push_string("test Text_Buf component");
817 qualified_name tc_fn_name;
818 tc_fn_name.module_name = "test tc_fn_name module_name";
819 tc_fn_name.definition_name = "test tc_fn_name definition_name";
820 const char *return_type = "test return_type";
821 int return_value_len = 10;
822 bool is_alive = true;
823 bool stop_requested = false;
824 bool process_killed = false;
825 // --- END OF DEBUG ---*/
827 // creating ComponentStruct
828 jclass cls
= env
->FindClass("org/eclipse/titan/executor/jni/ComponentStruct");
830 printf("Can't find class org.eclipse.titan.executor.jni.ComponentStruct\n");
834 jobject ComponentStruct
;
835 mid
= env
->GetMethodID(cls
, "<init>", "(I)V");
836 ComponentStruct
= env
->NewObject(cls
, mid
, text_buf
->get_len());
838 // processing struct fields
840 fid
= env
->GetFieldID(cls
, "comp_ref", "I");
842 printf("Can't find field comp_ref\n");
844 env
->SetIntField(ComponentStruct
, fid
, (jint
) comp_ref
);
847 fid
= env
->GetFieldID(cls
, "comp_type", "Lorg/eclipse/titan/executor/jni/QualifiedName;");
849 printf("Can't find field comp_type\n");
851 jclass cls_q
= env
->FindClass("org/eclipse/titan/executor/jni/QualifiedName");
852 if( cls_q
== NULL
) {
853 printf("Can't find class QualifiedName\n");
855 // creating new QualifiedName object
856 jmethodID mid_q
= env
->GetMethodID(cls_q
, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
857 jobject qname
= env
->NewObject(cls_q
, mid_q
, env
->NewStringUTF(comp_type
.module_name
),
858 env
->NewStringUTF(comp_type
.definition_name
));
859 env
->ExceptionClear();
860 env
->SetObjectField(ComponentStruct
, fid
, qname
);
863 fid
= env
->GetFieldID(cls
, "comp_name", "Ljava/lang/String;");
865 printf("Can't find field comp_name\n");
867 env
->SetObjectField(ComponentStruct
, fid
, env
->NewStringUTF(comp_name
));
870 fid
= env
->GetFieldID(cls
, "log_source", "Ljava/lang/String;");
872 printf("Can't find field log_source\n");
874 env
->SetObjectField(ComponentStruct
, fid
, env
->NewStringUTF(log_source
));
876 // comp_location ---------------------------------------
877 fid
= env
->GetFieldID(cls
, "comp_location", "Lorg/eclipse/titan/executor/jni/HostStruct;");
878 jclass cls_hs
= env
->FindClass("org/eclipse/titan/executor/jni/HostStruct");
879 if( cls_hs
== NULL
) {
880 printf("Can't find class org.eclipse.titan.executor.jni.HostStruct\n");
885 mid_hs
= env
->GetMethodID(cls_hs
, "<init>", "(IIII)V");
886 HostStruct
= env
->NewObject(cls_hs
, mid_hs
, 3, comp_location
->text_buf
->get_len(), comp_location
->n_components
, comp_location
->allowed_components
.n_elements
);
888 if(env
->ExceptionOccurred()) {
889 printf("error at creating HostStruct\n");
890 env
->ExceptionDescribe();
891 env
->ExceptionClear();
893 // processing struct fields
895 const char *ipaddr
= comp_location
->ip_addr
->get_addr_str();
896 fid_hs
= env
->GetFieldID(cls_hs
, "ip_addr", "Ljava/lang/String;");
898 printf("Can't find field hostname\n");
900 env
->SetObjectField(HostStruct
, fid_hs
, env
->NewStringUTF(ipaddr
));
903 fid_hs
= env
->GetFieldID(cls_hs
, "hostname", "Ljava/lang/String;");
905 printf("Can't find field hostname\n");
907 env
->SetObjectField(HostStruct
, fid_hs
, env
->NewStringUTF(comp_location
->hostname
));
910 fid_hs
= env
->GetFieldID(cls_hs
, "hostname_local", "Ljava/lang/String;");
912 printf("Can't find field hostname_local\n");
914 env
->SetObjectField(HostStruct
, fid_hs
, env
->NewStringUTF(comp_location
->hostname_local
));
917 fid_hs
= env
->GetFieldID(cls_hs
, "machine_type", "Ljava/lang/String;");
919 printf("Can't find field machine_type\n");
921 env
->SetObjectField(HostStruct
, fid_hs
, env
->NewStringUTF(comp_location
->machine_type
));
924 fid_hs
= env
->GetFieldID(cls_hs
, "system_name", "Ljava/lang/String;");
926 printf("Can't find field system_name\n");
928 env
->SetObjectField(HostStruct
, fid_hs
, env
->NewStringUTF(comp_location
->system_name
));
931 fid_hs
= env
->GetFieldID(cls_hs
, "system_release", "Ljava/lang/String;");
933 printf("Can't find field system_release\n");
935 env
->SetObjectField(HostStruct
, fid_hs
, env
->NewStringUTF(comp_location
->system_release
));
938 fid_hs
= env
->GetFieldID(cls_hs
, "system_version", "Ljava/lang/String;");
940 printf("Can't find field system_version\n");
942 env
->SetObjectField(HostStruct
, fid_hs
, env
->NewStringUTF(comp_location
->system_version
));
944 // transport_supported
945 fid_hs
= env
->GetFieldID(cls_hs
, "transport_supported", "[Z");
947 printf("Can't find field transport_supported\n");
949 jbooleanArray TransportSupported
= (jbooleanArray
)env
->GetObjectField(HostStruct
, fid_hs
);
950 env
->SetBooleanArrayRegion(TransportSupported
, (jsize
)0, 3,(jboolean
*)comp_location
->transport_supported
);
953 fid_hs
= env
->GetFieldID(cls_hs
, "log_source", "Ljava/lang/String;");
955 printf("Can't find field log_source\n");
957 env
->SetObjectField(HostStruct
, fid_hs
, env
->NewStringUTF(comp_location
->log_source
));
960 fid_hs
= env
->GetFieldID(cls_hs
, "hc_state", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
962 printf("Can't find field hc_state\n");
965 jclass cls_hs_hc
= env
->FindClass("org/eclipse/titan/executor/jni/HcStateEnum");
966 if( cls_hs_hc
== NULL
) {
967 printf("Can't find class org.eclipse.titan.executor.jni.HcStateEnum\n");
969 jfieldID fid_hs_hc
= 0;
971 switch(comp_location
->hc_state
) {
973 fid_hs_hc
= env
->GetStaticFieldID(cls_hs_hc
, "HC_IDLE", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
974 if (fid_hs_hc
== 0) {
975 printf("Can't find field HC_IDLE\n");
978 case mctr::HC_CONFIGURING
:
979 fid_hs_hc
= env
->GetStaticFieldID(cls_hs_hc
, "HC_CONFIGURING", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
980 if (fid_hs_hc
== 0) {
981 printf("Can't find field HC_CONFIGURING\n");
984 case mctr::HC_ACTIVE
:
985 fid_hs_hc
= env
->GetStaticFieldID(cls_hs_hc
, "HC_ACTIVE", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
986 if (fid_hs_hc
== 0) {
987 printf("Can't find field HC_ACTIVE\n");
990 case mctr::HC_OVERLOADED
:
991 fid_hs_hc
= env
->GetStaticFieldID(cls_hs_hc
, "HC_OVERLOADED", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
992 if (fid_hs_hc
== 0) {
993 printf("Can't find field HC_OVERLOADED\n");
996 case mctr::HC_CONFIGURING_OVERLOADED
:
997 fid_hs_hc
= env
->GetStaticFieldID(cls_hs_hc
, "HC_CONFIGURING_OVERLOADED", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
998 if (fid_hs_hc
== 0) {
999 printf("Can't find field HC_CONFIGURING_OVERLOADED\n");
1002 // ----------------------------------------------- 6-7
1003 case mctr::HC_EXITING
:
1004 fid_hs_hc
= env
->GetStaticFieldID(cls_hs_hc
, "HC_EXITING", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
1005 if (fid_hs_hc
== 0) {
1006 printf("Can't find field HC_EXITING\n");
1010 fid_hs_hc
= env
->GetStaticFieldID(cls_hs_hc
, "HC_DOWN", "Lorg/eclipse/titan/executor/jni/HcStateEnum;");
1011 if (fid_hs_hc
== 0) {
1012 printf("Can't find field HC_DOWN\n");
1016 printf("Unknown hc_state_enum state\n");
1018 ret
= env
->GetStaticObjectField(cls_hs_hc
, fid_hs_hc
);
1019 env
->ExceptionClear();
1020 env
->SetObjectField(HostStruct
, fid_hs
, ret
);
1023 fid_hs
= env
->GetFieldID(cls_hs
, "hc_fd", "I");
1025 printf("Can't find field hc_fd\n");
1027 env
->SetIntField(HostStruct
, fid_hs
, (jint
)comp_location
->hc_fd
);
1030 fid_hs
= env
->GetFieldID(cls_hs
, "text_buf", "[B");
1032 printf("Can't find field text_buf\n");
1034 jbyteArray TextBuf
= (jbyteArray
)env
->GetObjectField(HostStruct
, fid_hs
);
1035 env
->SetByteArrayRegion(TextBuf
, (jsize
)0, comp_location
->text_buf
->get_len(),
1036 const_cast<jbyte
*>((const jbyte
*)text_buf
->get_data()));
1039 fid_hs
= env
->GetFieldID(cls_hs
, "components", "[I");
1041 printf("Can't find field components\n");
1044 jintArray Components
= (jintArray
)env
->GetObjectField(HostStruct
, fid_hs
);
1045 env
->SetIntArrayRegion(Components
, (jsize
)0, comp_location
->n_components
, (jint
*)comp_location
->components
);
1047 // allowed_components
1048 fid_hs
= env
->GetFieldID(cls_hs
, "allowed_components", "[Ljava/lang/String;");
1050 printf("Can't find field allowed_components\n");
1052 jobjectArray allowedComponents
= (jobjectArray
) env
->GetObjectField(HostStruct
, fid_hs
);
1053 for(int i
= 0; i
< comp_location
->allowed_components
.n_elements
; i
++) {
1054 env
->SetObjectArrayElement(allowedComponents
, i
, env
->NewStringUTF(comp_location
->allowed_components
.elements
[i
]));
1057 // all_components_allowed
1058 fid_hs
= env
->GetFieldID(cls_hs
, "all_components_allowed", "Z");
1060 printf("Can't find field all_components_allowed\n");
1062 env
->SetBooleanField(HostStruct
, fid_hs
, (jboolean
)comp_location
->all_components_allowed
);
1064 // n_active_components
1065 fid_hs
= env
->GetFieldID(cls_hs
, "n_active_components", "I");
1067 printf("Can't find field n_active_components\n");
1069 env
->SetIntField(HostStruct
, fid_hs
, (jint
)comp_location
->n_active_components
);
1072 env
->SetObjectField(ComponentStruct
, fid
, HostStruct
); // finally setting inner host_struct
1073 // end of comp_location --------------------------------
1076 fid
= env
->GetFieldID(cls
, "tc_state", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1078 printf("Can't find field tc_state\n");
1081 jclass cls_tc
= env
->FindClass("org/eclipse/titan/executor/jni/TcStateEnum");
1082 if( cls_tc
== NULL
) {
1083 printf("Can't find class org.eclipse.titan.executor.jni.TcStateEnum\n");
1085 jfieldID fid_tc
= 0;
1088 case mctr::TC_INITIAL
:
1089 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_INITIAL", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1091 printf("Can't find field TC_INITIAL\n");
1095 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_IDLE", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1097 printf("Can't find field TC_IDLE\n");
1100 case mctr::TC_CREATE
:
1101 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_CREATE", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1103 printf("Can't find field TC_CREATE\n");
1106 case mctr::TC_START
:
1107 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_START", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1109 printf("Can't find field TC_START\n");
1113 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_STOP", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1115 printf("Can't find field TC_STOP\n");
1118 // ----------------------------------------------- 6-10
1120 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_KILL", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1122 printf("Can't find field TC_KILL\n");
1125 case mctr::TC_CONNECT
:
1126 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_CONNECT", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1128 printf("Can't find field TC_CONNECT\n");
1131 case mctr::TC_DISCONNECT
:
1132 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_DISCONNECT", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1134 printf("Can't find field TC_DISCONNECT\n");
1138 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_MAP", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1140 printf("Can't find field TC_MAP\n");
1143 case mctr::TC_UNMAP
:
1144 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_UNMAP", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1146 printf("Can't find field TC_UNMAP\n");
1149 // ----------------------------------------------- 11-15
1150 case mctr::TC_STOPPING
:
1151 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_STOPPING", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1153 printf("Can't find field TC_STOPPING\n");
1156 case mctr::TC_EXITING
:
1157 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_EXITING", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1159 printf("Can't find field TC_EXITING\n");
1162 case mctr::TC_EXITED
:
1163 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_EXITED", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1165 printf("Can't find field TC_EXITED\n");
1168 case mctr::MTC_CONTROLPART
:
1169 fid_tc
= env
->GetStaticFieldID(cls_tc
, "MTC_CONTROLPART", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1171 printf("Can't find field MTC_CONTROLPART\n");
1174 case mctr::MTC_TESTCASE
:
1175 fid_tc
= env
->GetStaticFieldID(cls_tc
, "MTC_TESTCASE", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1177 printf("Can't find field MTC_TESTCASE\n");
1180 // ----------------------------------------------- 16-20
1181 case mctr::MTC_ALL_COMPONENT_STOP
:
1182 fid_tc
= env
->GetStaticFieldID(cls_tc
, "MTC_ALL_COMPONENT_STOP", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1184 printf("Can't find field MTC_ALL_COMPONENT_STOP\n");
1187 case mctr::MTC_ALL_COMPONENT_KILL
:
1188 fid_tc
= env
->GetStaticFieldID(cls_tc
, "MTC_ALL_COMPONENT_KILL", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1190 printf("Can't find field MTC_ALL_COMPONENT_KILL\n");
1192 ret_tc
= env
->GetStaticObjectField(cls_tc
, fid_tc
);
1193 env
->ExceptionClear();
1195 case mctr::MTC_TERMINATING_TESTCASE
:
1196 fid_tc
= env
->GetStaticFieldID(cls_tc
, "MTC_TERMINATING_TESTCASE", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1198 printf("Can't find field MTC_TERMINATING_TESTCASE\n");
1201 case mctr::MTC_PAUSED
:
1202 fid_tc
= env
->GetStaticFieldID(cls_tc
, "MTC_PAUSED", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1204 printf("Can't find field MTC_PAUSED\n");
1207 case mctr::PTC_FUNCTION
:
1208 fid_tc
= env
->GetStaticFieldID(cls_tc
, "PTC_FUNCTION", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1210 printf("Can't find field PTC_FUNCTION\n");
1213 // ----------------------------------------------- 21-25
1214 case mctr::PTC_STARTING
:
1215 fid_tc
= env
->GetStaticFieldID(cls_tc
, "PTC_STARTING", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1217 printf("Can't find field PTC_STARTING\n");
1220 case mctr::PTC_STOPPED
:
1221 fid_tc
= env
->GetStaticFieldID(cls_tc
, "PTC_STOPPED", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1223 printf("Can't find field PTC_STOPPED\n");
1226 case mctr::PTC_KILLING
:
1227 fid_tc
= env
->GetStaticFieldID(cls_tc
, "PTC_KILLING", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1229 printf("Can't find field PTC_KILLING\n");
1232 case mctr::PTC_STOPPING_KILLING
:
1233 fid_tc
= env
->GetStaticFieldID(cls_tc
, "PTC_STOPPING_KILLING", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1235 printf("Can't find field PTC_STOPPING_KILLING\n");
1238 case mctr::PTC_STALE
:
1239 fid_tc
= env
->GetStaticFieldID(cls_tc
, "PTC_STALE", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1241 printf("Can't find field PTC_STALE\n");
1244 // ----------------------------------------------- 26
1245 case mctr::TC_SYSTEM
:
1246 fid_tc
= env
->GetStaticFieldID(cls_tc
, "TC_SYSTEM", "Lorg/eclipse/titan/executor/jni/TcStateEnum;");
1248 printf("Can't find field TC_SYSTEM\n");
1252 printf("Unknown tc_state_enum state\n");
1254 ret_tc
= env
->GetStaticObjectField(cls_tc
, fid_tc
);
1255 env
->ExceptionClear();
1256 env
->SetObjectField(ComponentStruct
, fid
, ret_tc
);
1259 fid
= env
->GetFieldID(cls
, "local_verdict", "Lorg/eclipse/titan/executor/jni/VerdictTypeEnum;");
1261 printf("Can't find field local_verdict\n");
1263 jclass cls_v
= env
->FindClass("org/eclipse/titan/executor/jni/VerdictTypeEnum");
1264 if( cls_v
== NULL
) {
1265 printf("Can't find class org.eclipse.titan.executor.jni.VerdictTypeEnum\n");
1269 switch(local_verdict
) {
1271 fid_v
= env
->GetStaticFieldID(cls_v
, "NONE", "Lorg/eclipse/titan/executor/jni/VerdictTypeEnum;");
1273 printf("Can't find field NONE\n");
1277 fid_v
= env
->GetStaticFieldID(cls_v
, "PASS", "Lorg/eclipse/titan/executor/jni/VerdictTypeEnum;");
1279 printf("Can't find field PASS\n");
1283 fid_v
= env
->GetStaticFieldID(cls_v
, "INCONC", "Lorg/eclipse/titan/executor/jni/VerdictTypeEnum;");
1285 printf("Can't find field INCONC\n");
1289 fid_v
= env
->GetStaticFieldID(cls_v
, "FAIL", "Lorg/eclipse/titan/executor/jni/VerdictTypeEnum;");
1291 printf("Can't find field FAIL\n");
1295 fid_v
= env
->GetStaticFieldID(cls_v
, "ERROR", "Lorg/eclipse/titan/executor/jni/VerdictTypeEnum;");
1297 printf("Can't find field ERROR\n");
1301 printf("Unknown tc_state_enum state\n");
1303 ret_v
= env
->GetStaticObjectField(cls_v
, fid_v
);
1304 env
->ExceptionClear();
1305 env
->SetObjectField(ComponentStruct
, fid
, ret_v
);
1308 fid
= env
->GetFieldID(cls
, "tc_fd", "I");
1310 printf("Can't find field tc_fd\n");
1312 env
->SetIntField(ComponentStruct
, fid
, (jint
)tc_fd
);
1315 fid
= env
->GetFieldID(cls
, "text_buf", "[B");
1317 printf("Can't find field text_buf\n");
1319 jbyteArray TextBuf_c
= (jbyteArray
)env
->GetObjectField(ComponentStruct
, fid
);
1320 env
->SetByteArrayRegion(TextBuf_c
, (jsize
)0, text_buf
->get_len(),
1321 const_cast<jbyte
*>((const jbyte
*)text_buf
->get_data()));
1324 fid
= env
->GetFieldID(cls
, "tc_fn_name", "Lorg/eclipse/titan/executor/jni/QualifiedName;");
1326 printf("Can't find field tc_fn_name\n");
1328 jclass cls_qualified
= env
->FindClass("org/eclipse/titan/executor/jni/QualifiedName");
1329 if( cls_qualified
== NULL
) {
1330 printf("Can't find class org.eclipse.titan.executor.jni.QualifiedName\n");
1332 jmethodID mid_qualified
;
1333 jobject QualifiedName
;
1334 mid_qualified
= env
->GetMethodID(cls_qualified
, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
1335 QualifiedName
= env
->NewObject(cls_qualified
, mid_qualified
, env
->NewStringUTF(tc_fn_name
.module_name
),
1336 env
->NewStringUTF(tc_fn_name
.definition_name
));
1337 env
->SetObjectField(ComponentStruct
, fid
, QualifiedName
);
1340 fid
= env
->GetFieldID(cls
, "return_type", "Ljava/lang/String;");
1342 printf("Can't find field return_type\n");
1344 env
->SetObjectField(ComponentStruct
, fid
, env
->NewStringUTF(return_type
));
1347 fid
= env
->GetFieldID(cls
, "return_value_len", "I");
1349 printf("Can't find field return_value_len\n");
1351 env
->SetIntField(ComponentStruct
, fid
, (jint
)return_value_len
);
1354 fid
= env
->GetFieldID(cls
, "is_alive", "Z");
1356 printf("Can't find field is_alive\n");
1358 env
->SetBooleanField(ComponentStruct
, fid
, (jboolean
)is_alive
);
1361 fid
= env
->GetFieldID(cls
, "stop_requested", "Z");
1363 printf("Can't find field stop_requested\n");
1365 env
->SetBooleanField(ComponentStruct
, fid
, (jboolean
)stop_requested
);
1368 fid
= env
->GetFieldID(cls
, "process_killed", "Z");
1370 printf("Can't find field process_killed\n");
1372 env
->SetBooleanField(ComponentStruct
, fid
, (jboolean
)process_killed
);
1374 return ComponentStruct
;
1377 JNIEXPORT
void JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_release_1data
1378 (JNIEnv
*, jobject
) {
1379 MainController::release_data();
1382 JNIEXPORT jstring JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1mc_1state_1name
1383 (JNIEnv
*env
, jobject
, jobject state
) {
1384 jclass cls
= env
->GetObjectClass(state
);
1386 printf("Can't find class org.eclipse.titan.executor.jni.McStateEnum\n");
1388 jmethodID mid
= env
->GetMethodID(cls
, "getValue", "()I");
1390 printf("Can't find method getValue\n");
1392 int value
= env
->CallIntMethod(state
, mid
);
1393 const char *state_name
= MainController::get_mc_state_name((mctr::mc_state_enum
)value
);
1394 return (env
->NewStringUTF(state_name
));
1397 JNIEXPORT jstring JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1hc_1state_1name
1398 (JNIEnv
*env
, jobject
, jobject state
) {
1399 jclass cls
= env
->GetObjectClass(state
);
1401 printf("Can't find class org.eclipse.titan.executor.jni.HcStateEnum\n");
1403 jmethodID mid
= env
->GetMethodID(cls
, "getValue", "()I");
1405 printf("Can't find method getValue\n");
1407 int value
= env
->CallIntMethod(state
, mid
);
1408 const char *state_name
= MainController::get_hc_state_name((mctr::hc_state_enum
)value
);
1409 return (env
->NewStringUTF(state_name
));
1412 JNIEXPORT jstring JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1tc_1state_1name
1413 (JNIEnv
*env
, jobject
, jobject state
) {
1414 jclass cls
= env
->GetObjectClass(state
);
1416 printf("Can't find class org.eclipse.titan.executor.jni.TcStateEnum\n");
1418 jmethodID mid
= env
->GetMethodID(cls
, "getValue", "()I");
1420 printf("Can't find method getValue\n");
1422 int value
= env
->CallIntMethod(state
, mid
);
1423 const char *state_name
= MainController::get_tc_state_name((mctr::tc_state_enum
)value
);
1424 return (env
->NewStringUTF(state_name
));
1427 JNIEXPORT jstring JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_get_1transport_1name
1428 (JNIEnv
*env
, jobject
, jobject transport
) {
1429 jclass cls
= env
->GetObjectClass(transport
);
1431 printf("Can't find class org.eclipse.titan.executor.jni.TransportTypeEnum\n");
1433 jmethodID mid
= env
->GetMethodID(cls
, "getValue", "()I");
1435 printf("Can't find method getValue\n");
1437 int value
= env
->CallIntMethod(transport
, mid
);
1438 const char *transport_name
= MainController::get_transport_name((transport_type_enum
)value
);
1439 return (env
->NewStringUTF(transport_name
));
1442 // *******************************************************
1443 // Other native functions
1444 // *******************************************************
1446 JNIEXPORT
void JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_check_1mem_1leak
1447 (JNIEnv
*env
, jobject
, jstring program_name
) {
1449 const char *p_name
= env
->GetStringUTFChars(program_name
, &iscopy
);
1450 check_mem_leak(p_name
);
1451 env
->ReleaseStringUTFChars(program_name
, p_name
);
1454 JNIEXPORT
void JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_print_1license_1info
1455 (JNIEnv
*, jobject
) {
1457 print_license_info();
1461 JNIEXPORT jint JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_check_1license
1462 (JNIEnv
*, jobject
) {
1465 license_struct lstr
;
1467 load_license(&lstr
);
1468 if (!verify_license(&lstr
)) {
1469 free_license(&lstr
);
1473 if (!check_feature(&lstr
, FEATURE_MCTR
)) {
1474 fputs("The license key does not allow the starting of TTCN-3 "
1475 "Main Controller.\n", stderr
);
1478 max_ptcs
= lstr
.max_ptcs
;
1479 free_license(&lstr
);
1484 return (jint
)max_ptcs
;
1487 JNIEXPORT jstring JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_readPipe
1488 (JNIEnv
*env
, jobject
) {
1489 char *buf
= Jnimw::userInterface
->read_pipe();
1490 return (env
->NewStringUTF(buf
));
1493 JNIEXPORT jboolean JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_isPipeReadable
1494 (JNIEnv
*, jobject
) {
1495 return ((jboolean
)Jnimw::userInterface
->is_pipe_readable());
1498 JNIEXPORT jlong JNICALL Java_org_eclipse_titan_executor_jni_JNIMiddleWare_getSharedLibraryVersion
1499 (JNIEnv
*, jclass
) {
1500 return (jlong
) TTCN3_VERSION
;