259 lines
11 KiB
C++
259 lines
11 KiB
C++
/* Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License, version 2.0,
|
|
as published by the Free Software Foundation.
|
|
|
|
This program is also distributed with certain software (including
|
|
but not limited to OpenSSL) that is licensed under separate terms,
|
|
as designated in a particular file or component or in included license
|
|
documentation. The authors of MySQL hereby grant you an additional
|
|
permission to link the program and your derivative works with the
|
|
separately licensed software that they have included with MySQL.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License, version 2.0, for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
#include "storage/perfschema/unittest/pfs_unit_test_conf.h"
|
|
|
|
#include <memory.h>
|
|
#include <string.h>
|
|
|
|
#include "my_thread.h"
|
|
#include "mysql/psi/psi_transaction.h"
|
|
#include "storage/perfschema/pfs_global.h"
|
|
#include "storage/perfschema/pfs_instr.h"
|
|
#include "storage/perfschema/pfs_instr_class.h"
|
|
#include "storage/perfschema/pfs_server.h"
|
|
#include "storage/perfschema/unittest/stub_pfs_defaults.h"
|
|
#include "storage/perfschema/unittest/stub_pfs_plugin_table.h"
|
|
#include "storage/perfschema/unittest/stub_print_error.h"
|
|
#include "unittest/mytap/tap.h"
|
|
|
|
static void test_noop() {
|
|
PSI_mutex *mutex;
|
|
PSI_rwlock *rwlock;
|
|
PSI_cond *cond;
|
|
PSI_socket *socket;
|
|
PSI_table_share *table_share;
|
|
PSI_table *table;
|
|
PSI_file *file;
|
|
PSI_thread *thread;
|
|
PSI_file_locker *file_locker;
|
|
PSI_idle_locker *idle_locker;
|
|
PSI_mutex_locker *mutex_locker;
|
|
PSI_rwlock_locker *rwlock_locker;
|
|
PSI_cond_locker *cond_locker;
|
|
PSI_table_locker *table_locker;
|
|
PSI_statement_locker *statement_locker;
|
|
PSI_transaction_locker *transaction_locker;
|
|
PSI_socket_locker *socket_locker;
|
|
PSI_digest_locker *digest_locker;
|
|
PSI_sp_locker *sp_locker;
|
|
PSI_sp_share *sp_share;
|
|
PSI_memory_key memory_key;
|
|
PSI_metadata_lock *metadata_lock;
|
|
PSI_metadata_locker *metadata_locker;
|
|
PSI_thread *owner;
|
|
|
|
diag("test_noop");
|
|
|
|
psi_mutex_service->register_mutex(NULL, NULL, 0);
|
|
psi_rwlock_service->register_rwlock(NULL, NULL, 0);
|
|
psi_cond_service->register_cond(NULL, NULL, 0);
|
|
psi_thread_service->register_thread(NULL, NULL, 0);
|
|
psi_file_service->register_file(NULL, NULL, 0);
|
|
psi_stage_service->register_stage(NULL, NULL, 0);
|
|
psi_statement_service->register_statement(NULL, NULL, 0);
|
|
psi_socket_service->register_socket(NULL, NULL, 0);
|
|
|
|
ok(true, "register");
|
|
mutex = psi_mutex_service->init_mutex(1, NULL);
|
|
ok(mutex == NULL, "no mutex");
|
|
psi_mutex_service->destroy_mutex(NULL);
|
|
rwlock = psi_rwlock_service->init_rwlock(1, NULL);
|
|
ok(rwlock == NULL, "no rwlock");
|
|
psi_rwlock_service->destroy_rwlock(NULL);
|
|
cond = psi_cond_service->init_cond(1, NULL);
|
|
ok(cond == NULL, "no cond");
|
|
psi_cond_service->destroy_cond(NULL);
|
|
socket = psi_socket_service->init_socket(1, NULL, NULL, 0);
|
|
ok(socket == NULL, "no socket");
|
|
psi_socket_service->destroy_socket(NULL);
|
|
table_share = psi_table_service->get_table_share(false, NULL);
|
|
ok(table_share == NULL, "no table_share");
|
|
psi_table_service->release_table_share(NULL);
|
|
psi_table_service->drop_table_share(false, NULL, 0, NULL, 0);
|
|
table = psi_table_service->open_table(NULL, NULL);
|
|
ok(table == NULL, "no table");
|
|
psi_table_service->unbind_table(NULL);
|
|
table = psi_table_service->rebind_table(NULL, NULL, NULL);
|
|
ok(table == NULL, "no table");
|
|
psi_table_service->close_table(NULL, NULL);
|
|
psi_file_service->create_file(1, NULL, 2);
|
|
/* TODO: spawn thread */
|
|
thread = psi_thread_service->new_thread(1, NULL, 2);
|
|
ok(thread == NULL, "no thread");
|
|
psi_thread_service->set_thread_id(NULL, 1);
|
|
thread = psi_thread_service->get_thread();
|
|
ok(thread == NULL, "no thread");
|
|
psi_thread_service->set_thread_user(NULL, 0);
|
|
psi_thread_service->set_thread_account(NULL, 0, NULL, 0);
|
|
psi_thread_service->set_thread_db(NULL, 0);
|
|
psi_thread_service->set_thread_command(1);
|
|
psi_thread_service->set_thread_start_time(1);
|
|
psi_thread_service->set_thread_info(NULL, 0);
|
|
psi_thread_service->set_thread(NULL);
|
|
psi_thread_service->aggregate_thread_status(NULL);
|
|
psi_thread_service->delete_current_thread();
|
|
psi_thread_service->delete_thread(NULL);
|
|
file_locker = psi_file_service->get_thread_file_name_locker(
|
|
NULL, 1, PSI_FILE_OPEN, NULL, NULL);
|
|
ok(file_locker == NULL, "no file_locker");
|
|
file_locker = psi_file_service->get_thread_file_stream_locker(NULL, NULL,
|
|
PSI_FILE_OPEN);
|
|
ok(file_locker == NULL, "no file_locker");
|
|
file_locker = psi_file_service->get_thread_file_descriptor_locker(
|
|
NULL, 0, PSI_FILE_OPEN);
|
|
ok(file_locker == NULL, "no file_locker");
|
|
psi_mutex_service->unlock_mutex(NULL);
|
|
psi_rwlock_service->unlock_rwlock(NULL, PSI_RWLOCK_UNLOCK);
|
|
psi_cond_service->signal_cond(NULL);
|
|
psi_cond_service->broadcast_cond(NULL);
|
|
idle_locker = psi_idle_service->start_idle_wait(NULL, NULL, 0);
|
|
ok(idle_locker == NULL, "no idle_locker");
|
|
psi_idle_service->end_idle_wait(NULL);
|
|
mutex_locker =
|
|
psi_mutex_service->start_mutex_wait(NULL, NULL, PSI_MUTEX_LOCK, NULL, 0);
|
|
ok(mutex_locker == NULL, "no mutex_locker");
|
|
psi_mutex_service->end_mutex_wait(NULL, 0);
|
|
rwlock_locker = psi_rwlock_service->start_rwlock_rdwait(
|
|
NULL, NULL, PSI_RWLOCK_READLOCK, NULL, 0);
|
|
ok(rwlock_locker == NULL, "no rwlock_locker");
|
|
psi_rwlock_service->end_rwlock_rdwait(NULL, 0);
|
|
rwlock_locker = psi_rwlock_service->start_rwlock_wrwait(
|
|
NULL, NULL, PSI_RWLOCK_WRITELOCK, NULL, 0);
|
|
ok(rwlock_locker == NULL, "no rwlock_locker");
|
|
psi_rwlock_service->end_rwlock_wrwait(NULL, 0);
|
|
cond_locker = psi_cond_service->start_cond_wait(NULL, NULL, NULL,
|
|
PSI_COND_WAIT, NULL, 0);
|
|
ok(cond_locker == NULL, "no cond_locker");
|
|
psi_cond_service->end_cond_wait(NULL, 0);
|
|
table_locker = psi_table_service->start_table_io_wait(
|
|
NULL, NULL, PSI_TABLE_FETCH_ROW, 0, NULL, 0);
|
|
ok(table_locker == NULL, "no table_locker");
|
|
psi_table_service->end_table_io_wait(NULL, 0);
|
|
table_locker = psi_table_service->start_table_lock_wait(
|
|
NULL, NULL, PSI_TABLE_LOCK, 0, NULL, 0);
|
|
ok(table_locker == NULL, "no table_locker");
|
|
psi_table_service->end_table_lock_wait(NULL);
|
|
psi_file_service->start_file_open_wait(NULL, NULL, 0);
|
|
file = psi_file_service->end_file_open_wait(NULL, NULL);
|
|
ok(file == NULL, "no file");
|
|
psi_file_service->end_file_open_wait_and_bind_to_descriptor(NULL, 0);
|
|
psi_file_service->start_file_wait(NULL, 0, NULL, 0);
|
|
psi_file_service->end_file_wait(NULL, 0);
|
|
psi_file_service->start_file_close_wait(NULL, NULL, 0);
|
|
psi_file_service->end_file_close_wait(NULL, 0);
|
|
psi_file_service->end_file_rename_wait(NULL, NULL, NULL, 0);
|
|
psi_stage_service->start_stage(1, NULL, 0);
|
|
|
|
PSI_stage_progress *progress;
|
|
progress = psi_stage_service->get_current_stage_progress();
|
|
ok(progress == NULL, "no progress");
|
|
|
|
psi_stage_service->end_stage();
|
|
statement_locker =
|
|
psi_statement_service->get_thread_statement_locker(NULL, 1, NULL, NULL);
|
|
ok(statement_locker == NULL, "no statement_locker");
|
|
statement_locker = psi_statement_service->refine_statement(NULL, 1);
|
|
ok(statement_locker == NULL, "no statement_locker");
|
|
psi_statement_service->start_statement(NULL, NULL, 0, NULL, 0);
|
|
psi_statement_service->set_statement_text(NULL, NULL, 0);
|
|
psi_statement_service->set_statement_lock_time(NULL, 0);
|
|
psi_statement_service->set_statement_rows_sent(NULL, 0);
|
|
psi_statement_service->set_statement_rows_examined(NULL, 0);
|
|
psi_statement_service->inc_statement_created_tmp_disk_tables(NULL, 0);
|
|
psi_statement_service->inc_statement_created_tmp_tables(NULL, 0);
|
|
psi_statement_service->inc_statement_select_full_join(NULL, 0);
|
|
psi_statement_service->inc_statement_select_full_range_join(NULL, 0);
|
|
psi_statement_service->inc_statement_select_range(NULL, 0);
|
|
psi_statement_service->inc_statement_select_range_check(NULL, 0);
|
|
psi_statement_service->inc_statement_select_scan(NULL, 0);
|
|
psi_statement_service->inc_statement_sort_merge_passes(NULL, 0);
|
|
psi_statement_service->inc_statement_sort_range(NULL, 0);
|
|
psi_statement_service->inc_statement_sort_rows(NULL, 0);
|
|
psi_statement_service->inc_statement_sort_scan(NULL, 0);
|
|
psi_statement_service->set_statement_no_index_used(NULL);
|
|
psi_statement_service->set_statement_no_good_index_used(NULL);
|
|
psi_statement_service->end_statement(NULL, NULL);
|
|
socket_locker = psi_socket_service->start_socket_wait(
|
|
NULL, NULL, PSI_SOCKET_SEND, 1, NULL, 0);
|
|
ok(socket_locker == NULL, "no socket_locker");
|
|
psi_socket_service->end_socket_wait(NULL, 0);
|
|
psi_socket_service->set_socket_state(NULL, PSI_SOCKET_STATE_IDLE);
|
|
psi_socket_service->set_socket_info(NULL, NULL, NULL, 0);
|
|
psi_socket_service->set_socket_thread_owner(NULL);
|
|
digest_locker = psi_statement_service->digest_start(NULL);
|
|
ok(digest_locker == NULL, "no digest_locker");
|
|
psi_statement_service->digest_end(NULL, NULL);
|
|
sp_locker = psi_statement_service->start_sp(NULL, NULL);
|
|
ok(sp_locker == NULL, "no sp_locker");
|
|
psi_statement_service->end_sp(NULL);
|
|
psi_statement_service->drop_sp(0, NULL, 0, NULL, 0);
|
|
sp_share = psi_statement_service->get_sp_share(0, NULL, 0, NULL, 0);
|
|
ok(sp_share == NULL, "no sp_share");
|
|
psi_statement_service->release_sp_share(NULL);
|
|
psi_memory_service->register_memory(NULL, NULL, 0);
|
|
memory_key = psi_memory_service->memory_alloc(0, 0, &owner);
|
|
ok(memory_key == PSI_NOT_INSTRUMENTED, "no memory_key");
|
|
memory_key = psi_memory_service->memory_realloc(0, 0, 0, &owner);
|
|
ok(memory_key == PSI_NOT_INSTRUMENTED, "no memory_key");
|
|
psi_memory_service->memory_free(0, 0, NULL);
|
|
psi_table_service->unlock_table(NULL);
|
|
metadata_lock =
|
|
psi_mdl_service->create_metadata_lock(NULL, NULL, 1, 2, 3, NULL, 0);
|
|
ok(metadata_lock == NULL, "no metadata_lock");
|
|
psi_mdl_service->set_metadata_lock_status(NULL, 0);
|
|
psi_mdl_service->destroy_metadata_lock(NULL);
|
|
metadata_locker = psi_mdl_service->start_metadata_wait(NULL, NULL, NULL, 0);
|
|
ok(metadata_locker == NULL, "no metadata_locker");
|
|
psi_mdl_service->end_metadata_wait(NULL, 0);
|
|
|
|
transaction_locker = psi_transaction_service->get_thread_transaction_locker(
|
|
NULL, NULL, NULL, 1, false, 1);
|
|
ok(transaction_locker == NULL, "no transaction_locker");
|
|
psi_transaction_service->start_transaction(NULL, NULL, 0);
|
|
psi_transaction_service->end_transaction(NULL, true);
|
|
|
|
psi_transaction_service->set_transaction_gtid(NULL, NULL, NULL);
|
|
psi_transaction_service->set_transaction_trxid(NULL, NULL);
|
|
psi_transaction_service->set_transaction_xa_state(NULL, 1);
|
|
psi_transaction_service->set_transaction_xid(NULL, NULL, 1);
|
|
psi_transaction_service->inc_transaction_release_savepoint(NULL, 1);
|
|
psi_transaction_service->inc_transaction_rollback_to_savepoint(NULL, 1);
|
|
psi_transaction_service->inc_transaction_savepoints(NULL, 1);
|
|
|
|
psi_thread_service->set_thread_THD(NULL, NULL);
|
|
|
|
psi_error_service->log_error(0, PSI_ERROR_OPERATION_RAISED);
|
|
ok(true, "no error");
|
|
|
|
ok(true, "all noop api called");
|
|
}
|
|
|
|
int main(int, char **) {
|
|
plan(35);
|
|
|
|
MY_INIT("pfs_noop-t");
|
|
test_noop();
|
|
my_end(0);
|
|
return (exit_status());
|
|
}
|