Viet-Hung Dang

Year	Rank	Type	Title / Venue / Authors
2026	J	`jnl`	A single-to-multiple framework for structural dynamic prediction via graph data representation and mixed strategy deep learning. Eng. Appl. Artif. Intell. Truong-Thang Nguyen, Viet-Hung Dang, Ngoc-Son Vu, Manh-Hung Ha, Xuan-Dat Pham
2026	J	`jnl`	Investigation of seismic reliability analysis of non-linear steel structures utilizing quantile regression deep learning. Neural Comput. Appl. Van-Thuat Dinh, Long Giang Nguyen, Viet-Hung Dang, Thuy-Duong Tran, Truong-Thang Nguyen
2025	J	`jnl`	Deep Learning-Driven Throughput Maximization in Covert Communication for UAV-RIS Cognitive Systems. IEEE Open J. Commun. Soc. Van Nhan Vo, Nguyen Quoc Long, Viet-Hung Dang, Tu Dac Ho, Hung Tran, Symeon Chatzinotas, Dinh Hieu Tran, Surasak Sanguanpong, Chakchai So-In
2025	J	`jnl`	Efficient reliability analysis method for non-linear truss structures using machine learning-based uncertainty quantification. Comput. Math. Appl. Trung-Hieu Nguyen, Truong-Thang Nguyen, Duc-Minh Hoang, Viet-Hung Dang, Xuan-Dat Pham
2024	—	`conf`	A Novel Privacy Preserving Framework for Training Dempster-Shafer Theory-Based Evidential Deep Neural Network. BELIEF Anh-Tu Tran, Van-Nam Huynh, Viet-Hung Dang
2024	J	`jnl`	An efficient k-NN-based rao optimization method for optimal discrete sizing of truss structures. Appl. Soft Comput. Hoang-Anh Pham, Viet-Hung Dang, Tien-Chuong Vu, Ba-Duan Nguyen
2024	J	`jnl`	Development of an adaptive reliability analysis framework for reinforced concrete frame structures using uncertainty quantification. Appl. Intell. Truong-Thang Nguyen, Viet-Hung Dang, Manh-Hung Ha, Thanh-Tung Pham, Quang-Minh Phan
2024	—	`conf`	Throughput Maximization for UAV-RIS NOMA Cognitive Systems in Disaster Communications. RIVF Nguyen Quoc Long, Van Nhan Vo, Viet-Hung Dang, Hung Tran, Dinh-Hieu Tran, Zhenni Pan, Shigeru Shimamoto, Tu Dac Ho
2024	J	`jnl`	Towards Vietnamese Question and Answer Generation: An Empirical Study. ACM Trans. Asian Low Resour. Lang. Inf. Process. Pham Quoc-Hung, Huu-Loi Le, Dang Nhat Minh, T. Tran Khang, Manh Tran-Tien, Viet-Hung Dang, Huy-The Vu, Minh-Tien Nguyen, Xuan-Hieu Phan
2023	—	`conf`	An Innovative Blockchain-Based Traceability Framework for Industry 4.0 Cyber-Physical Factory. APIT William Davis, Mahnoor Yaqoob, Luke Bennett, Stefan Mihai, Viet-Hung Dang, Ramona Trestian, Mehmet Karamanoglu, Balbir Barn, Huan Xuan Nguyen
2023	J	`jnl`	Deep Learning for Outage Probability Minimization in Secure NOMA Energy Harvesting UAV IoT Networks. Mob. Networks Appl. Nguyen Quoc Long, Viet-Hung Dang, Nhu Gia Nguyen, Thanh Trong Nguyen, Tu Dac Ho, Hung Tran, Duc-Dung Tran, Cong Le Thanh, Van Nhan Vo
2023	J	`jnl`	Outage Probability Minimization in Secure NOMA Cognitive Radio Systems With UAV Relay: A Machine Learning Approach. IEEE Trans. Cogn. Commun. Netw. Van Nhan Vo, Le-Mai-Duyen Nguyen, Hung Tran, Viet-Hung Dang, Dusit Niyato, Dang Ngoc Cuong, Nguyen Cong Luong, Chakchai So-In
2023	—	`conf`	Packet Timeout Probability for Cognitive Cooperative Radio Network under Security Constraint. SoICT Hung Tran, Tung Pham Huu, Tu Lam Thanh, Giang Le Quynh Vu, Trinh Van Chien, Viet-Hung Dang, Van Nhan Vo
2023	J	`jnl`	Probabilistic incremental dynamic analysis of structures using temporal surrogate model. Appl. Intell. Truong-Thang Nguyen, Viet-Hung Dang
2023	J	`jnl`	Secondary Network Throughput Optimization of NOMA Cognitive Radio Networks Under Power and Secure Constraints. IEEE Access Van Nhan Vo, Viet-Hung Dang, Hung Tran, Dac-Binh Ha, Cong Le, Tu Dac Ho, Chakchai So-In
2023	—	`conf`	Security and Reliability Performance Analysis of Cognitive NOMA Network Under Outage Constraint of Multiple Primary Users. SoICT Tung Pham Huu, Hung Tran, Duc-Tan Tran, Viet-Hung Dang, Van Nhan Vo, Nguyen Dinh Viet
2023	J	`jnl`	Throughput Optimization for Noma Energy Harvesting Cognitive Radio With Multi-UAV-Assisted Relaying Under Security Constraints. IEEE Trans. Cogn. Commun. Netw. Viet-Hung Dang, Le-Mai-Duyen Nguyen, Van Nhan Vo, Hung Tran, Tu Dac Ho, Chakchai So-In, Surasak Sanguanpong
2023	J	`jnl`	Vibration-based building health monitoring using spatio-temporal learning model. Eng. Appl. Artif. Intell. Viet-Hung Dang, Hoang-Anh Pham
2022	—	`conf`	A DNA Steganography Algorithm Based on The DNA-XOR Technique. RICE Vinh-Quy Nguyen, Dinh-Chien Nguyen, Viet-Hung Dang, Thanh-Hue Nguyen Thi, Thu-Hang Phan Thi, Dinh-Thinh Luu
2021	J	`jnl`	Constrained representation learning for recurrent policy optimisation under uncertainty. Adapt. Behav. Viet-Hung Dang, Ngo Anh Vien, TaeChoong Chung
2021	—	`conf`	Physical Layer Security in Cognitive Radio Networks for IoT Using UAV With Reconfigurable Intelligent Surfaces. JCSSE Van Nhan Vo, Nguyen Quoc Long, Viet-Hung Dang, Chakchai So-In, Anh-Nhat Nguyen, Hung Tran
2021	J	`jnl`	Throughput analysis and optimization for NOMA Multi-UAV assisted disaster communication using CMA-ES. Wirel. Networks Le-Mai-Duyen Nguyen, Van Nhan Vo, Chakchai So-In, Viet-Hung Dang
2020	J	`jnl`	Asynchronous framework with Reptile+ algorithm to meta learn partially observable Markov decision process. Appl. Intell. Dang Quang Nguyen, Ngo Anh Vien, Viet-Hung Dang, TaeChoong Chung
2020	J	`jnl`	Improving Path Planning Methods in 2D Grid Maps. J. Comput. Viet-Hung Dang, Hoang Huu Viet, Nguyen Duc Thang, Ngo Anh Vien, Le Anh Tuan
2019	J	`jnl`	A covariance matrix adaptation evolution strategy in reproducing kernel Hilbert space. Genet. Program. Evolvable Mach. Viet-Hung Dang, Ngo Anh Vien, TaeChoong Chung
2017	C	`conf`	A Covariance Matrix Adaptation Evolution Strategy for Direct Policy Search in Reproducing Kernel Hilbert Space. ACML Ngo Anh Vien, Viet-Hung Dang, TaeChoong Chung
2017	—	`conf`	A Functional Optimization Method for Continuous Domains. INISCOM Viet-Hung Dang, Ngo Anh Vien, Pham Le-Tuyen, TaeChoong Chung
2015	J	`jnl`	Batch-Theta* for path planning to the best goal in a goal set. Adv. Robotics Viet-Hung Dang, Nguyen Duc Thang, Hoang Huu Viet, Le Anh Tuan
2015	J	`jnl`	BoB: an online coverage approach for multi-robot systems. Appl. Intell. Hoang Huu Viet, Viet-Hung Dang, Seung Yoon Choi, TaeChoong Chung
2015	J	`jnl`	Sequential Multidimensional Scaling with Kalman Filtering for Location Tracking. Int. J. Distributed Sens. Networks Lan Anh Trinh, Nguyen Duc Thang, Viet-Hung Dang, Tran Cong Hung
2013	J	`jnl`	BA*: an online complete coverage algorithm for cleaning robots. Appl. Intell. Hoang Huu Viet, Viet-Hung Dang, Md Nasir Uddin Laskar, TaeChoong Chung
2013	J	`jnl`	Monte-Carlo tree search for Bayesian reinforcement learning. Appl. Intell. Ngo Anh Vien, Wolfgang Ertel, Viet-Hung Dang, TaeChoong Chung
2013	J	`jnl`	Nonlinear controls of a rotating tower crane in conjunction with trolley motion. J. Syst. Control. Eng. Le Anh Tuan, Viet-Hung Dang, Deok H. Ko, Tran N. An, Soon-Geul Lee
2013	—	`ch.`	Recognizing and Tagging Vietnamese Words Based on Statistics and Word Order Patterns. Advanced Methods for Computational Collective Intelligence Hieu Le Trung, Vu Le Anh, Viet-Hung Dang, Hai Vo Hoang
2012	J	`jnl`	A distributed design for multiple moving source positioning. J. Supercomput. Viet-Hung Dang, Sungyoung Lee, Young-Koo Lee
2011	J	`jnl`	Distributed Push-pull Estimation for node localization in wireless sensor networks. J. Parallel Distributed Comput. Viet-Hung Dang, Duc Viet Le, Young-Koo Lee, Sungyoung Lee
2011	J	`jnl`	Towards Smart Homes Using Low Level Sensory Data. Sensors Asad Masood Khattak, Phan Tran Ho Truc, Le Xuan Hung, La The Vinh, Viet-Hung Dang, Donghai Guan, Zeeshan Pervez, Manhyung Han, Sungyoung Lee, Young-Koo Lee
2010	—	`conf`	Acoustic multiple object positioning system. PE-WASUN Viet-Hung Dang, Thuong Le-Tien, Young-Koo Lee, Sungyoung Lee
2010	—	`conf`	Secured WSN-integrated cloud computing for u-Life Care. CCNC Xuan Hung Le, Sungyoung Lee, Phan Tran Ho Truc, La The Vinh, Asad Masood Khattak, Manhyung Han, Viet-Hung Dang, Mohammad Mehedi Hassan, Miso Kim, Koo Kyo Ho, Young-Koo Lee, Eui-Nam Huh

"""
Integration tests for ELF-specific extractors.
"""
import pytest
from unittest.mock import Mock, patch, MagicMock

pytestmark = [pytest.mark.integration, pytest.mark.elf]


# ============================================================================
# ELFFeaturesExtractor Tests
# ============================================================================

class TestELFFeaturesExtractor:
    """Tests for ELFFeaturesExtractor class."""

    def test_extract_valid_elf(self, elf_binary_path, mock_logger):
        """Test extracting features from valid ELF file."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor
        from redb.models.dataclasses import ELFFeatures

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            assert isinstance(result, ELFFeatures)

    def test_extract_header_data(self, elf_binary_path, mock_logger):
        """Test ELF header data extraction."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            # Check header fields
            assert isinstance(result.ei_class, int)
            assert isinstance(result.ei_data, int)
            assert isinstance(result.e_type, int)
            assert isinstance(result.e_machine, int)
            assert isinstance(result.e_entry, int)

    def test_extract_human_readable_strings(self, elf_binary_path, mock_logger):
        """Test human-readable string fields."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            assert result.ei_class_str in ['32-bit', '64-bit', 'unknown']
            assert result.ei_data_str in ['Little-endian', 'Big-endian', 'unknown']
            assert result.e_type_str is not None
            assert result.e_machine_str is not None

    def test_extract_security_properties(self, elf_binary_path, mock_logger):
        """Test security property extraction."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            # Security flags should be 0 or 1
            assert result.is_pie in [0, 1]
            assert result.has_canary in [0, 1]
            assert result.has_nx in [0, 1]
            assert result.has_relro in [0, 1]
            assert result.has_fortify in [0, 1]

    def test_extract_counts(self, elf_binary_path, mock_logger):
        """Test section/segment/symbol counts."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            assert result.number_of_segments >= 0
            assert result.number_of_sections >= 0
            assert result.number_of_symbols >= 0
            assert result.number_of_dynamic_symbols >= 0
            assert result.number_of_relocations >= 0
            assert result.number_of_dependencies >= 0

    def test_extract_build_info(self, elf_binary_path, mock_logger):
        """Test build information extraction."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            # Build ID may or may not be present
            if result.build_id is not None:
                assert isinstance(result.build_id, str)
            assert result.gnu_hash_present in [0, 1]
            assert result.has_debug_info in [0, 1]

    def test_extract_invalid_elf(self, pe_binary_path, mock_logger):
        """Test extraction with non-ELF file."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(pe_binary_path, mock_logger)

            result = extractor.extract()

            # Should return None for invalid ELF
            assert result is None


# ============================================================================
# ELFSectionExtractor Tests
# ============================================================================

class TestELFSectionExtractor:
    """Tests for ELFSectionExtractor class."""

    def test_extract_sections(self, elf_binary_path, mock_logger):
        """Test section extraction."""
        from redb.extractors.elf_extractors.elf_sections import ELFSectionExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSectionExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            assert isinstance(result, list)
            assert len(result) > 0

    def test_section_properties(self, elf_binary_path, mock_logger):
        """Test section property extraction."""
        from redb.extractors.elf_extractors.elf_sections import ELFSectionExtractor
        from redb.models.dataclasses import ELFSection

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSectionExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None and len(result) > 0:
                section = result[0]
                assert isinstance(section, ELFSection)
                assert section.section_name is not None
                assert isinstance(section.section_type, int)
                assert isinstance(section.section_flags, int)
                assert section.section_entropy >= 0

    def test_section_hashes(self, elf_binary_path, mock_logger):
        """Test section hash computation."""
        from redb.extractors.elf_extractors.elf_sections import ELFSectionExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSectionExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None and len(result) > 0:
                for section in result:
                    if section.section_sha256:
                        assert len(section.section_sha256) == 64
                    if section.section_md5:
                        assert len(section.section_md5) == 32


# ============================================================================
# ELFSegmentExtractor Tests
# ============================================================================

class TestELFSegmentExtractor:
    """Tests for ELFSegmentExtractor class."""

    def test_extract_segments(self, elf_binary_path, mock_logger):
        """Test segment extraction."""
        from redb.extractors.elf_extractors.elf_segments import ELFSegmentExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSegmentExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            assert isinstance(result, list)

    def test_segment_properties(self, elf_binary_path, mock_logger):
        """Test segment property extraction."""
        from redb.extractors.elf_extractors.elf_segments import ELFSegmentExtractor
        from redb.models.dataclasses import ELFSegment

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSegmentExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None and len(result) > 0:
                segment = result[0]
                assert isinstance(segment, ELFSegment)
                assert isinstance(segment.segment_type, int)
                assert isinstance(segment.segment_flags, int)


# ============================================================================
# ELFSymbolExtractor Tests
# ============================================================================

class TestELFSymbolExtractor:
    """Tests for ELFSymbolExtractor class."""

    def test_extract_symbols(self, elf_binary_path, mock_logger):
        """Test symbol extraction."""
        from redb.extractors.elf_extractors.elf_symbols import ELFSymbolExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSymbolExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            # May be None if stripped
            if result is not None:
                assert isinstance(result, list)

    def test_symbol_properties(self, elf_binary_path, mock_logger):
        """Test symbol property extraction."""
        from redb.extractors.elf_extractors.elf_symbols import ELFSymbolExtractor
        from redb.models.dataclasses import ELFSymbol

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSymbolExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None and len(result) > 0:
                symbol = result[0]
                assert isinstance(symbol, ELFSymbol)
                assert symbol.symbol_name is not None
                assert isinstance(symbol.symbol_type, int)
                assert isinstance(symbol.symbol_bind, int)


# ============================================================================
# ELFImportExtractor Tests
# ============================================================================

class TestELFImportExtractor:
    """Tests for ELFImportExtractor class."""

    def test_extract_imports(self, elf_binary_path, mock_logger):
        """Test import extraction."""
        from redb.extractors.elf_extractors.elf_imports import ELFImportExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFImportExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            # May be None if no imports
            if result is not None:
                assert hasattr(result, 'elf_imports_total')

    def test_import_functions(self, elf_binary_path, mock_logger):
        """Test import function extraction."""
        from redb.extractors.elf_extractors.elf_imports import ELFImportExtractor
        from redb.models.dataclasses import ELFImport

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFImportExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None:
                assert isinstance(result, ELFImport)
                assert isinstance(result.elf_imports_total, int)


# ============================================================================
# ELFExportExtractor Tests
# ============================================================================

class TestELFExportExtractor:
    """Tests for ELFExportExtractor class."""

    def test_extract_exports(self, elf_binary_path, mock_logger):
        """Test export extraction."""
        from redb.extractors.elf_extractors.elf_exports import ELFExportExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFExportExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            # May be None if no exports
            if result is not None:
                assert hasattr(result, 'elf_exports_total')

    def test_export_functions(self, elf_binary_path, mock_logger):
        """Test export function extraction."""
        from redb.extractors.elf_extractors.elf_exports import ELFExportExtractor
        from redb.models.dataclasses import ELFExport

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFExportExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None:
                assert isinstance(result, ELFExport)


# ============================================================================
# ELFDependencyExtractor Tests
# ============================================================================

class TestELFDependencyExtractor:
    """Tests for ELFDependencyExtractor class."""

    def test_extract_dependencies(self, elf_binary_path, mock_logger):
        """Test dependency extraction."""
        from redb.extractors.elf_extractors.elf_dependencies import ELFDependencyExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFDependencyExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            # May be None if no dependencies
            if result is not None:
                assert isinstance(result, list)

    def test_dependency_properties(self, elf_binary_path, mock_logger):
        """Test dependency property extraction."""
        from redb.extractors.elf_extractors.elf_dependencies import ELFDependencyExtractor
        from redb.models.dataclasses import ELFDependency

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFDependencyExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None and len(result) > 0:
                dep = result[0]
                assert isinstance(dep, ELFDependency)
                assert dep.dependency_name is not None


# ============================================================================
# ELFRelocationExtractor Tests
# ============================================================================

class TestELFRelocationExtractor:
    """Tests for ELFRelocationExtractor class."""

    def test_extract_relocations(self, elf_binary_path, mock_logger):
        """Test relocation extraction."""
        from redb.extractors.elf_extractors.elf_relocations import ELFRelocationExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFRelocationExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            # May be None if no relocations
            if result is not None:
                assert isinstance(result, list)

    def test_relocation_properties(self, elf_binary_path, mock_logger):
        """Test relocation property extraction."""
        from redb.extractors.elf_extractors.elf_relocations import ELFRelocationExtractor
        from redb.models.dataclasses import ELFRelocation

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFRelocationExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None and len(result) > 0:
                reloc = result[0]
                assert isinstance(reloc, ELFRelocation)
                assert isinstance(reloc.relocation_offset, int)
                assert isinstance(reloc.relocation_type, int)


# ============================================================================
# ELFNotesExtractor Tests
# ============================================================================

class TestELFNotesExtractor:
    """Tests for ELFNotesExtractor class."""

    def test_extract_notes(self, elf_binary_path, mock_logger):
        """Test notes extraction."""
        from redb.extractors.elf_extractors.elf_notes import ELFNotesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFNotesExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            # May be None if no notes
            if result is not None:
                assert isinstance(result, list)

    def test_note_properties(self, elf_binary_path, mock_logger):
        """Test note property extraction."""
        from redb.extractors.elf_extractors.elf_notes import ELFNotesExtractor
        from redb.models.dataclasses import ELFNote

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFNotesExtractor(elf_binary_path, mock_logger)

            result = extractor.extract()

            if result is not None and len(result) > 0:
                note = result[0]
                assert isinstance(note, ELFNote)
                assert note.note_name is not None
                assert isinstance(note.note_type, int)


# ============================================================================
# Integration Tests
# ============================================================================

class TestELFExtractorIntegration:
    """Integration tests for ELF extractors."""

    def test_all_extractors_valid_elf(self, elf_binary_path, mock_logger):
        """Test all ELF extractors with valid ELF file."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor
        from redb.extractors.elf_extractors.elf_sections import ELFSectionExtractor
        from redb.extractors.elf_extractors.elf_segments import ELFSegmentExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            features_ext = ELFFeaturesExtractor(elf_binary_path, mock_logger)
            sections_ext = ELFSectionExtractor(elf_binary_path, mock_logger)
            segments_ext = ELFSegmentExtractor(elf_binary_path, mock_logger)

            features_result = features_ext.extract()
            sections_result = sections_ext.extract()
            segments_result = segments_ext.extract()

            # All should extract something
            assert features_result is not None
            assert sections_result is not None
            assert segments_result is not None

    def test_hash_consistency_across_extractors(self, elf_binary_path, mock_logger):
        """Test that hashes are consistent across all extractors."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor
        from redb.extractors.elf_extractors.elf_sections import ELFSectionExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            features_ext = ELFFeaturesExtractor(elf_binary_path, mock_logger)
            sections_ext = ELFSectionExtractor(elf_binary_path, mock_logger)

            # Hashes should be the same
            assert features_ext.sha256 == sections_ext.sha256
            assert features_ext.md5 == sections_ext.md5
            assert features_ext.sha1 == sections_ext.sha1

    def test_clickhouse_tables_unique(self, elf_binary_path, mock_logger):
        """Test that each extractor has a unique ClickHouse table."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor
        from redb.extractors.elf_extractors.elf_sections import ELFSectionExtractor
        from redb.extractors.elf_extractors.elf_segments import ELFSegmentExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            features_ext = ELFFeaturesExtractor(elf_binary_path, mock_logger)
            sections_ext = ELFSectionExtractor(elf_binary_path, mock_logger)
            segments_ext = ELFSegmentExtractor(elf_binary_path, mock_logger)

            tables = {
                features_ext.get_clickhouse_table(),
                sections_ext.get_clickhouse_table(),
                segments_ext.get_clickhouse_table(),
            }

            # All tables should be unique
            assert len(tables) == 3


# ============================================================================
# Advanced Binary Tests
# ============================================================================

class TestELFAdvancedBinary:
    """Tests using the hello_advanced binary."""

    def test_advanced_features_extraction(self, elf_advanced_binary_path, mock_logger):
        """Test feature extraction from advanced ELF binary."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(elf_advanced_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            assert result.number_of_sections > 0

    def test_advanced_sections_extraction(self, elf_advanced_binary_path, mock_logger):
        """Test section extraction from advanced ELF binary."""
        from redb.extractors.elf_extractors.elf_sections import ELFSectionExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSectionExtractor(elf_advanced_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            assert len(result) > 0

            # Check for common ELF sections
            section_names = [s.section_name for s in result]
            # Most ELF files have .text section
            assert any('.text' in name for name in section_names)

    def test_advanced_segments_extraction(self, elf_advanced_binary_path, mock_logger):
        """Test segment extraction from advanced ELF binary."""
        from redb.extractors.elf_extractors.elf_segments import ELFSegmentExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSegmentExtractor(elf_advanced_binary_path, mock_logger)

            result = extractor.extract()

            assert result is not None
            assert len(result) > 0


# ============================================================================
# Export Data Tests
# ============================================================================

class TestELFExtractorExportData:
    """Tests for export data preparation."""

    def test_features_prepare_export_clickhouse(self, elf_binary_path, mock_logger):
        """Test ClickHouse export preparation for features."""
        from redb.extractors.elf_extractors.elf_features import ELFFeaturesExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFFeaturesExtractor(elf_binary_path, mock_logger)
            extractor.extract()

            result = extractor.prepare_export_data("ClickHouseExporter")

            assert result is not None
            data, column_names, column_type_names = result

            assert 'sha256' in column_names
            assert 'ei_class' in column_names
            assert 'e_machine' in column_names
            assert 'is_pie' in column_names

    def test_sections_prepare_export_clickhouse(self, elf_binary_path, mock_logger):
        """Test ClickHouse export preparation for sections."""
        from redb.extractors.elf_extractors.elf_sections import ELFSectionExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSectionExtractor(elf_binary_path, mock_logger)
            extractor.extract()

            result = extractor.prepare_export_data("ClickHouseExporter")

            if result is not None:
                data, column_names, column_type_names = result
                assert 'section_name' in column_names
                assert 'section_entropy' in column_names

    def test_segments_prepare_export_clickhouse(self, elf_binary_path, mock_logger):
        """Test ClickHouse export preparation for segments."""
        from redb.extractors.elf_extractors.elf_segments import ELFSegmentExtractor

        with patch('redb.settings.ELASTIC_BINARIES_COLLECTION', 'test'):
            extractor = ELFSegmentExtractor(elf_binary_path, mock_logger)
            extractor.extract()

            result = extractor.prepare_export_data("ClickHouseExporter")

            if result is not None:
                data, column_names, column_type_names = result
                assert 'segment_type' in column_names