Merge pull request 'dev/v1.0.3' (#3) from dev/v1.0.3 into master

Reviewed-on: #3

build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 group = "ru.thiflict.binaryutils"
-version = "1.0.0"
+version = "1.0.3"
 
 repositories {
     mavenCentral()
@@ -27,7 +27,7 @@ publishing {
         create<MavenPublication>("maven") {
             groupId = "ru.thiflict.binaryutils"
             artifactId = "binary-utils"
-            version = "1.0.0"
+            version = "1.0.3"
 
             from(components["java"])
         }

publish.sh

@@ -1,2 +1,4 @@
+# Этот скрипт для обычных юзеров ничего из себя не представляет
+# Только для меинтеинера.
 export $(cat .env | xargs)
 ./gradlew publish

readme.md

@@ -1,5 +1,5 @@
 # BinaryUtils
-пока пох на описание лмао
+Детальная информация о проекте лежит в Wiki
 
 как импортировать в проект:
 
@@ -12,6 +12,6 @@ repositories {
 
 dependencies {
     // Добавить в dependencies
-    implementation("ru.thiflict.binaryutils:binary-utils:1.0.0")
+    implementation("ru.thiflict.binaryutils:binary-utils:1.0.3") // У релизов всегда актуальная версия
 }
 ```

src/main/kotlin/BinCheck.kt

@@ -17,14 +17,39 @@ object BinCheck {
      * Тип данных для проверяемого числа [Short].
      * Тип данных для проверяемого регистра [Byte]
      *
+     * Регистр *не может быть* **отрицательным** или **больше 15**
+     *
      * Пример:
      * ```
      * checkRegisterShort(8, 3)
      * ```
-     * @return true
+     * @return [Boolean]
+     * @throws IllegalArgumentException
      */
-    fun checkRegisterShort(input: Short, register: Byte): Boolean {
+    fun checkRegisterShort(input: Short, register: Byte, verbose: Boolean = false): Boolean {
+        // Защиты от дурачков
+        if (register < 0) throw IllegalArgumentException("Проверяемый регистр не может быть отрицательным!")
+        if (register > 15) throw IllegalArgumentException("Проверяемый регистр не может быть больше, чем количество регистров Short!")
+
+        if (verbose) println("Debug: checkRegisterShort(): Выполнена проверка на IllegalArgumentException")
+
         val binaryString = String.format("%16s", input.toInt().toString(2).replace(' ', '0'))
+
+        if (verbose) println("Debug: checkRegisterShort(): ${
+            if (binaryString.startsWith("-")) {
+                val binaryStringFormatted = binaryString
+                    .drop(1)
+                    .chunked(4)
+                    .joinToString(" ")
+                "-$binaryStringFormatted"
+            }
+            else {
+                binaryString
+                    .chunked(4)
+                    .joinToString(" ")
+            }
+        }")
+
         val index = 15 - register.toInt()
         return binaryString[index] == '1'
     }

src/main/kotlin/BinConvert.kt

@@ -0,0 +1,85 @@
+package ru.thiflict.binaryutils
+
+/**
+ * Объект выполняет конвертации чисел из одной системы счисления в другую.
+ *
+ * Репозиторий: https://git.ds1.thiflict.ru/Thiflict/BinaryUtils
+ *
+ * @author Thiflict
+ *
+ * @since[1.0.3]
+ */
+object BinConvert {
+
+    /**
+     * Преобразует значение типа [Long] в строку, представляющую его 64-битное двоичное представление.
+     *
+     * Биты выводятся от старшего (индекс 63) к младшему (индекс 0). Каждый бит представлен символом '0' или '1'.
+     *
+     * Результат всегда содержит ровно 64 символа, включая ведущие нули.
+     *
+     * @return строка длиной 64 символа, состоящая из нулей и единиц, соответствующая двоичному представлению числа.
+     */
+    fun Long.toBinary(): String {
+        return (0..63)
+            .reversed()
+            .map { bit -> (this shr bit) and 1 }
+            .joinToString("")
+    }
+
+    /**
+     * Преобразует значение типа [Int] в целое число, десятичная запись которого
+     *
+     * совпадает с 32-битным двоичным представлением исходного числа (включая ведущие нули).
+     *
+     * Биты перебираются от старшего (индекс 31) к младшему (индекс 0).
+     *
+     * Полученная строка из символов '0' и '1' интерпретируется как десятичное число.
+     *
+     * @return целое число, десятичное представление которого повторяет 32-битную двоичную форму исходного значения.
+     */
+    fun Int.toBinary(): String {
+        return (0..31)
+            .reversed()
+            .map { bit -> (this shr bit) and 1 }
+            .joinToString("")
+    }
+
+    /**
+     * Преобразует значение типа [Short] в целое число, десятичная запись которого
+     *
+     * совпадает с 16-битным двоичным представлением исходного числа (включая ведущие нули).
+     *
+     * Значение [Short] перед обработкой приводится к [Int]. Биты перебираются от старшего (индекс 15)
+     *
+     * к младшему (индекс 0). Полученная строка из '0' и '1' интерпретируется как десятичное число.
+     *
+     * @return целое число, десятичное представление которого повторяет 16-битную двоичную форму исходного значения.
+     */
+    fun Short.toBinary(): Long {
+        return (0..15)
+            .reversed()
+            .map { bit -> (this.toInt() shr bit) and 1 }
+            .joinToString("")
+            .toLong()
+    }
+
+    /**
+     * Преобразует значение типа [Byte] в целое число, десятичная запись которого
+     *
+     * совпадает с 8-битным двоичным представлением исходного числа (включая ведущие нули).
+     *
+     * Значение [Byte] перед обработкой приводится к [Int]. Биты перебираются от старшего (индекс 7)
+     *
+     * к младшему (индекс 0). Полученная строка из '0' и '1' интерпретируется как десятичное число.
+     *
+     * @return целое число, десятичное представление которого повторяет 8-битную двоичную форму исходного значения.
+     */
+    fun Byte.toBinary(): Int {
+        return (0..7)
+            .reversed()
+            .map { bit -> (this.toInt() shr bit) and 1 }
+            .joinToString("")
+            .toInt()
+    }
+}

src/main/kotlin/BinGetters.kt

@@ -0,0 +1,50 @@
+package ru.thiflict.binaryutils
+
+/**
+ * Объект для получения каких либо данных из вводимого числа
+ *
+ * Репозиторий: https://git.ds1.thiflict.ru/Thiflict/BinaryUtils
+ *
+ * @author Thiflict
+ *
+ * @since[1.0.2]
+ */
+
+object BinGetters {
+
+    /**
+     * Возвращает индекс первого старшего бита из вводимого числа.
+     * Если в числе нет старшего бита, то возвращает `null`
+     *
+     * Тип данных для проверяемого числа: [Short].
+     *
+     * Пример:
+     * ```
+     * getFirstHighBitShort(67)
+     * ```
+     * @return [Byte]
+     * @since[1.0.2 не тестировалось на отрицательные числа]
+     */
+    fun getFirstHighBitShort(input: Short): Byte? {
+        return run {
+            // Для числа 0 возвращаем null
+            if (input == 0.toShort()) {
+                return null
+            }
+
+            // Используем bitwise operations для корректной работы с отрицательными числами
+            var value = input.toInt() and 0xFFFF // Преобразуем в беззнаковое 16-битное число
+            var result: Byte? = null
+
+            // Ищем первый установленный бит с начала (от старших к младшим)
+            for (index in 15 downTo 0) {
+                if (value and (1 shl index) != 0) {
+                    result = index.toByte()
+                    break
+                }
+            }
+
+            result
+        }
+    }
+}

src/test/kotlin/BinConvertTest.kt

@@ -0,0 +1,160 @@
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import ru.thiflict.binaryutils.BinConvert.toBinary
+
+
+class BinConvertTest {
+
+    // ------------------- Long.toBinary() -------------------
+    @Test
+    fun `Long toBinary zero`() {
+        val expected = "0".repeat(64)
+        assertEquals(expected, 0L.toBinary())
+    }
+
+    @Test
+    fun `Long toBinary positive one`() {
+        val expected = "0".repeat(63) + "1"
+        assertEquals(expected, 1L.toBinary())
+    }
+
+    @Test
+    fun `Long toBinary negative one`() {
+        val expected = "1".repeat(64)
+        assertEquals(expected, (-1L).toBinary())
+    }
+
+    @Test
+    fun `Long toBinary MAX_VALUE`() {
+        // Long.MAX_VALUE = 0x7FFFFFFFFFFFFFFF -> первый бит 0, остальные 63 бита 1
+        val expected = "0" + "1".repeat(63)
+        assertEquals(expected, Long.MAX_VALUE.toBinary())
+    }
+
+    @Test
+    fun `Long toBinary MIN_VALUE`() {
+        // Long.MIN_VALUE = 0x8000000000000000 -> первый бит 1, остальные 63 бита 0
+        val expected = "1" + "0".repeat(63)
+        assertEquals(expected, Long.MIN_VALUE.toBinary())
+    }
+
+    @Test
+    fun `Long toBinary arbitrary value`() {
+        // 123456789L = 0x75BCD15 -> двоичное представление из 64 бит
+        val expectedBinaryString = java.lang.Long.toBinaryString(123456789L).padStart(64, '0')
+        assertEquals(expectedBinaryString, 123456789L.toBinary())
+    }
+
+    // ------------------- Int.toBinary() -------------------
+    @Test
+    fun `Int toBinary zero`() {
+        assertEquals("0".repeat(32), 0.toBinary())
+    }
+
+    @Test
+    fun `Int toBinary positive one`() {
+        assertEquals("0".repeat(31) + "1", 1.toBinary())
+    }
+
+    @Test
+    fun `Int toBinary negative one`() {
+        assertEquals("1".repeat(32), (-1).toBinary())
+    }
+
+    @Test
+    fun `Int toBinary MAX_VALUE`() {
+        // Int.MAX_VALUE = 0x7FFFFFFF -> 0 + 31 единица
+        assertEquals("0" + "1".repeat(31), Int.MAX_VALUE.toBinary())
+    }
+
+    @Test
+    fun `Int toBinary MIN_VALUE`() {
+        // Int.MIN_VALUE = 0x80000000 -> 1 + 31 ноль
+        assertEquals("1" + "0".repeat(31), Int.MIN_VALUE.toBinary())
+    }
+
+    @Test
+    fun `Int toBinary arbitrary value`() {
+        val value = -987654321
+        val expected = Integer.toBinaryString(value).padStart(32, '0')
+        assertEquals(expected, value.toBinary())
+    }
+
+    // ------------------- Short.toBinary() -------------------
+    @Test
+    fun `Short toBinary zero returns Long`() {
+        // бинарная строка из 16 нулей -> Long = 0
+        assertEquals(0L, (0).toShort().toBinary())
+    }
+
+    @Test
+    fun `Short toBinary positive one`() {
+        // "0000000000000001" -> 1L
+        assertEquals(1L, (1).toShort().toBinary())
+    }
+
+    @Test
+    fun `Short toBinary negative one`() {
+        // "1111111111111111" -> 1111111111111111L
+        assertEquals(1111111111111111L, (-1).toShort().toBinary())
+    }
+
+    @Test
+    fun `Short toBinary MAX_VALUE`() {
+        // 0x7FFF -> "0111111111111111" -> 111111111111111L (15 единиц)
+        assertEquals(111111111111111L, Short.MAX_VALUE.toBinary())
+    }
+
+    @Test
+    fun `Short toBinary MIN_VALUE`() {
+        // 0x8000 -> "1000000000000000" -> 1000000000000000L
+        assertEquals(1000000000000000L, Short.MIN_VALUE.toBinary())
+    }
+
+    @Test
+    fun `Short toBinary arbitrary positive`() {
+        // 12345 = 0x3039 -> binary: 0011000000111001
+        val expected = "0011000000111001".toLong() // 11000000111001 -> 11000000111001L? Actually leading zeros are ignored.
+        // "0011000000111001" -> decimal 11000000111001? Let's compute: 0011000000111001 -> 11000000111001 (14 digits) = 11,000,000,111,001? Wait, the string is 16 chars: 0011000000111001.
+        // toLong will parse as decimal: 11000000111001? The leading zeros don't change the numeric value.
+        // The result: 0011000000111001 as decimal is 11000000111001? Let's count: after removing leading zeros, string is "11000000111001" which is 11,000,000,111,001? Actually "11000000111001" is 14 digits: 11 trillion something.
+        // But it's easier to build directly: val expected = "0011000000111001".toLong() works.
+        assertEquals("0011000000111001".toLong(), (12345).toShort().toBinary())
+    }
+
+    // ------------------- Byte.toBinary() -------------------
+    @Test
+    fun `Byte toBinary zero returns Int`() {
+        assertEquals(0, (0).toByte().toBinary())
+    }
+
+    @Test
+    fun `Byte toBinary positive one`() {
+        // "00000001" -> 1
+        assertEquals(1, (1).toByte().toBinary())
+    }
+
+    @Test
+    fun `Byte toBinary negative one`() {
+        // "11111111" -> 11111111
+        assertEquals(11111111, (-1).toByte().toBinary())
+    }
+
+    @Test
+    fun `Byte toBinary MAX_VALUE`() {
+        // 0x7F -> "01111111" -> 1111111 (7 единиц)
+        assertEquals(1111111, Byte.MAX_VALUE.toBinary())
+    }
+
+    @Test
+    fun `Byte toBinary MIN_VALUE`() {
+        // 0x80 -> "10000000" -> 10000000
+        assertEquals(10000000, Byte.MIN_VALUE.toBinary())
+    }
+
+    @Test
+    fun `Byte toBinary arbitrary value`() {
+        // 42 = 0x2A -> "00101010" -> 101010
+        assertEquals(101010, (42).toByte().toBinary())
+    }
+}

src/test/kotlin/CheckRegisterTest.kt

@@ -35,4 +35,11 @@ fun main() {
 
     // Тест 10: Проверка значения -1 в регистре 0 (должно быть true, так как все биты установлены)
     println("Тест 10: checkRegisterShort(-1, 0) = ${checkRegisterShort(-1, 0.toByte())}")
+
+    // Тест на кидание IllegalArgumentException №1
+//    println("Тест 11: checkRegisterShort(5, -1) = ${checkRegisterShort(5, (-1).toByte())}")
+
+    // Тест на кидание IllegalArgumentException №2
+//    println("Тест 11: checkRegisterShort(25, 16) = ${checkRegisterShort(32767.toShort(), 15.toByte(), true)}")
+
 }

src/test/kotlin/GetFirstHighBitShortTest.kt

@@ -0,0 +1,43 @@
+import ru.thiflict.binaryutils.BinGetters.getFirstHighBitShort
+
+fun main() {
+    // Тест 1: Число 67 (00000000 01000011 в двоичном виде)
+    val test1 = getFirstHighBitShort(67.toShort())
+    println("Тест 1 - число 67: $test1") // Ожидается 6
+
+    // Тест 2: Число 0 (все биты нули)
+    val test2 = getFirstHighBitShort(0.toShort())
+    println("Тест 2 - число 0: $test2") // Ожидается null
+
+    // Тест 3: Число 1 (только младший бит установлен)
+    val test3 = getFirstHighBitShort(1.toShort())
+    println("Тест 3 - число 1: $test3") // Ожидается 0
+
+    // Тест 4: Число 32767 (максимальное положительное Short число)
+    val test4 = getFirstHighBitShort(32767.toShort())
+    println("Тест 4 - число 32767: $test4") // Ожидается 14
+
+    // Тест 5: Число 16384 (только старший бит установлен)
+    val test5 = getFirstHighBitShort(16384.toShort())
+    println("Тест 5 - число 16384: $test5") // Ожидается 14
+
+    // Тест 6: Число 256 (второй бит с конца установлен)
+    val test6 = getFirstHighBitShort(256.toShort())
+    println("Тест 6 - число 256: $test6") // Ожидается 8
+
+    // Тест 7: Число 128 (восьмой бит с конца установлен)
+    val test7 = getFirstHighBitShort(128.toShort())
+    println("Тест 7 - число 128: $test7") // Ожидается 7
+
+    // Тест 8: Число 255 (младшие 8 бит установлены)
+    val test8 = getFirstHighBitShort(255.toShort())
+    println("Тест 8 - число 255: $test8") // Ожидается 7
+
+    // Тест 9: Число 32768 (внешний бит установлен - отрицательное число)
+    val test9 = getFirstHighBitShort((-32768).toShort())
+    println("Тест 9 - число -32768: $test9") // Ожидается 15
+
+    // Тест 10: Число -1 (все биты установлены)
+    val test10 = getFirstHighBitShort((-1).toShort())
+    println("Тест 10 - число -1: $test10") // Ожидается 15
+}