Битвы языковых моделей: сравниваем LLM Т-Банка с конкурентами в рабочих условиях

#!/bin/bash  # Определяем базовую директорию  BASE_DIR="/home/marat/Downloads"  # Создаем директории для разных типов файлов  IMAGES_DIR="$BASE_DIR/images"  PDFS_DIR="$BASE_DIR/pdfs"  VIDEOS_DIR="$BASE_DIR/videos"  # Функция для создания директории, если она не существует  create_dir() {      if [ ! -d "$1" ]; then          mkdir -p "$1"          echo "Создана директория: $1"      else          echo "Директория уже существует: $1"      fi  }  # Создаем необходимые директории  create_dir "$IMAGES_DIR"  create_dir "$PDFS_DIR"  create_dir "$VIDEOS_DIR"  # Функция для копирования файлов  copy_files() {      local source_pattern="$1"      local dest_dir="$2"      local file_type="$3"            # Находим файлы и копируем их      find "$BASE_DIR" -maxdepth 1 -type f -iname "$source_pattern" -exec cp -v {} "$dest_dir/" \;            # Проверяем, были ли скопированы файлы      if [ $? -eq 0 ]; then          echo "Файлы типа $file_type скопированы в $dest_dir"      else          echo "Не найдены файлы типа $file_type или произошла ошибка при копировании"      fi  }  # Копируем изображения (PNG и JPG)  copy_files "*.png" "$IMAGES_DIR" "PNG"  copy_files "*.jpg" "$IMAGES_DIR" "JPG"  copy_files "*.jpeg" "$IMAGES_DIR" "JPEG"  # Копируем PDF файлы  copy_files "*.pdf" "$PDFS_DIR" "PDF"  # Копируем видео файлы  copy_files "*.mp4" "$VIDEOS_DIR" "MP4"  echo "Сортировка файлов завершена!"

#!/bin/bash  # Определяем базовую директорию  BASE_DIR="/home/marat/Downloads"  # Создаем необходимые поддиректории, если они не существуют  mkdir -p "$BASE_DIR/images"  mkdir -p "$BASE_DIR/pdf"  mkdir -p "$BASE_DIR/videos"  # Копируем файлы в соответствующие папки  echo "Копирование изображений (PNG и JPG)..."  find "$BASE_DIR" -maxdepth 1 \( -iname "*.png" -o -iname "*.jpg" -o -iname "*.jpeg" \) -exec cp {} "$BASE_DIR/images/" \;  echo "Копирование PDF файлов..."  find "$BASE_DIR" -maxdepth 1 -iname "*.pdf" -exec cp {} "$BASE_DIR/pdf/" \;  echo "Копирование видео (MP4) файлов..."  find "$BASE_DIR" -maxdepth 1 -iname "*.mp4" -exec cp {} "$BASE_DIR/videos/" \;  echo "Организация завершена."

#!/bin/bash  # Указание пути к папке Downloads  DOWNLOADS_DIR="/home/marat/Downloads"  # Создание папок для PNG/JPG, PDF и MP4 файлов  mkdir -p "$DOWNLOADS_DIR/Images"  mkdir -p "$DOWNLOADS_DIR/Documents"  mkdir -p "$DOWNLOADS_DIR/Videos"  # Копирование PNG и JPG файлов в папку Images  find "$DOWNLOADS_DIR" -maxdepth 1 -type f \( -iname "*.png" -o -iname "*.jpg" -o -iname "*.jpeg" \) -exec mv {} "$DOWNLOADS_DIR/Images/" \;  # Копирование PDF файлов в папку Documents  find "$DOWNLOADS_DIR" -maxdepth 1 -type f -iname "*.pdf" -exec mv {} "$DOWNLOADS_DIR/Documents/" \;  # Копирование MP4 файлов в папку Videos  find "$DOWNLOADS_DIR" -maxdepth 1 -type f -iname "*.mp4" -exec mv {} "$DOWNLOADS_DIR/Videos/" \;  echo "Файлы успешно распределены по папкам!"

#!/bin/bash  # Путь к Downloads  downloads_dir="/home/marat/Downloads"  # Проверяем существование директории и создаем её если не существует  if [ ! -d "$downloads_dir" ]; then      echo "Directory $downloads_dir does not exist. Creating it..."      mkdir "$downloads_dir"  fi  # Создаем папки для различных типов файлов  mkdir -p "$downloads_dir"/PNG_JPG  mkdir -p "$downloads_dir"/PDF  mkdir -p "$downloads_dir"/MP4  # Функция для копирования файлов по расширению в соответствующие папки  move_files() {      local extension="$1"      local target_dir="$2"      for file in "$downloads_dir"/*."$extension"; do          if [ -f "$file" ]; then              echo "Moving $file to $target_dir..."              mv -v "$file" "$downloads_dir/$target_dir/"          fi      done  }  # Копируем файлы по расширениям  move_files "png" "PNG_JPG"  move_files "jpg" "PNG_JPG"  move_files "pdf" "PDF"  move_files "mp4" "MP4"  echo "All files have been moved to the respective directories."

// Начнём с сущности пользователя — классика для любого приложения  @Entity(tableName = "users")  data class User(      @PrimaryKey val uid: Int,      @ColumnInfo(name = "first_name") val firstName: String,      @ColumnInfo(name = "last_name") val lastName: String,      @ColumnInfo(name = "email") val email: String,      @ColumnInfo(name = "created_at") val createdAt: Long = System.currentTimeMillis()  )  // DAO для работы с базой — стандартный набор CRUD-операций  @Dao  interface UserDao {      @Query("SELECT * FROM users")      fun getAll(): Flow<List<User>>      @Query("SELECT * FROM users WHERE uid IN (:userIds)")      fun loadAllByIds(userIds: IntArray): Flow<List<User>>      @Insert      suspend fun insertAll(vararg users: User)      @Delete      suspend fun delete(user: User)  }  // Room Database — ничего необычного, просто связываем всё воедино  @Database(entities = [User::class], version = 1)  abstract class AppDatabase : RoomDatabase() {      abstract fun userDao(): UserDao  }  // Repository — классический паттерн для абстракции работы с данными  class UserRepository @Inject constructor(      private val userDao: UserDao  ) {      fun getAllUsers(): Flow<List<User>> = userDao.getAll()      suspend fun addUser(user: User) = userDao.insertAll(user)      suspend fun deleteUser(user: User) = userDao.delete(user)  }  // И наконец, ViewModel — здесь вся бизнес-логика и состояние UI  @HiltViewModel  class UserViewModel @Inject constructor(      private val userRepository: UserRepository  ) : ViewModel() {      private val _users = MutableStateFlow<List<User>>(emptyList())      val users: StateFlow<List<User>> = _users.asStateFlow()      init {          viewModelScope.launch {              userRepository.getAllUsers()                  .collect { users ->                      _users.value = users                  }          }      }  }

@Test  fun initial state should be empty list() = runTest {      val usersFlow = flowOf(emptyList<User>())      coEvery { repository.getAllUsers() } returns usersFlow      viewModel = UserViewModel(repository)      assertEquals(emptyList<User>(), viewModel.users.value)  }  @Test  fun should collect users from repository() = runTest {      val testUsers = listOf(          User(1, "John", "Doe", "john@example.com"),          User(2, "Jane", "Smith", "jane@example.com")      )      val usersFlow = flowOf(testUsers)      coEvery { repository.getAllUsers() } returns usersFlow      viewModel = UserViewModel(repository)      testDispatcher.scheduler.advanceUntilIdle()      assertEquals(testUsers, viewModel.users.value)  }  @Test  fun should handle repository errors gracefully() = runTest {      val errorFlow = flow<List<User>> {           throw IOException("Network error")       }      coEvery { repository.getAllUsers() } returns errorFlow      viewModel = UserViewModel(repository)      testDispatcher.scheduler.advanceUntilIdle()      assertEquals(emptyList<User>(), viewModel.users.value)  }

import app.cash.turbine.test  import io.mockk.*  import kotlinx.coroutines.Dispatchers  import kotlinx.coroutines.ExperimentalCoroutinesApi  import kotlinx.coroutines.flow.Flow  import kotlinx.coroutines.flow.MutableStateFlow  import kotlinx.coroutines.flow.flow  import kotlinx.coroutines.test.*  import org.junit.Assert.*  import org.junit.Before  import org.junit.Rule  import org.junit.Test  import org.junit.rules.TestRule  import org.junit.runner.RunWith  import org.mockito.junit.MockitoJUnitRunner  @ExperimentalCoroutinesApi  @RunWith(MockitoJUnitRunner::class)  class UserViewModelTest {      private lateinit var userRepository: UserRepository      private lateinit var userViewModel: UserViewModel      private val testDispatcher = StandardTestDispatcher()      @get:Rule      val rule: TestRule = TestCoroutineRule()      @Before      fun setup() {          userRepository = mockk()          Dispatchers.setMain(testDispatcher)          userViewModel = UserViewModel(userRepository)      }      @Test      fun should collect users successfully() = runTest {          val users = listOf(              User(1, "John", "Doe", "john@example.com"),              User(2, "Jane", "Doe", "jane@example.com")          )          val userFlow: Flow<List<User>> = flow { emit(users) }          coEvery { userRepository.getAllUsers() } returns userFlow                    userViewModel = UserViewModel(userRepository)                    userViewModel.users.test {              assertEquals(users, awaitItem())          }      }      @Test      fun should handle empty user list() = runTest {          val emptyUserFlow: Flow<List<User>> = flow { emit(emptyList()) }          coEvery { userRepository.getAllUsers() } returns emptyUserFlow                    userViewModel = UserViewModel(userRepository)                    userViewModel.users.test {              assertTrue(awaitItem().isEmpty())          }      }      @Test      fun should handle repository error() = runTest {          val errorFlow: Flow<List<User>> = flow { throw RuntimeException("Database error") }          coEvery { userRepository.getAllUsers() } returns errorFlow                    userViewModel = UserViewModel(userRepository)                    userViewModel.users.test {              assertTrue(awaitItem().isEmpty()) // ViewModel должна обрабатывать ошибки и не падать          }      }  }

Разбор тестов:

1. should collect users successfully

   • Проверяет, что UserViewModel корректно собирает пользователей из Flow репозитория.

2. should handle empty user list

   • Убеждается, что UserViewModel корректно обрабатывает пустой список.

3. should handle repository error

   • Симулирует ошибку в Flow и проверяет, что UserViewModel не падает.

Используем Turbine для тестирования StateFlow и mockk для мокирования зависимостей. Если что-то улучшить – пиши! 🚀

Анализируя кодовую базу, мы видим, что UserViewModel использует корутины и потоки данных (Flow`) для    получения списка пользователей из базы данных. Давайте напишем юнит-тесты, чтобы убедиться в правильности    работы с этими механизмами.  ### Шаг 1: Подготовка тестовой среды  Для начала нам нужно подготовить тестовую среду для UserViewModel. Это может включать создание моков и    инжекцию их в UserViewModel для изоляции тестирования. Мы будем использовать Mockito и Mockk.  ### Шаг 2: Написание юнит-тестов  Давайте напишем несколько тестов, чтобы проверить работу UserViewModel.  ```kotlin  import androidx.arch.core.executor.testing.InstantTaskExecutorRule  import kotlinx.coroutines.Dispatchers  import kotlinx.coroutines.test.runBlockingTest  import org.junit.Assert.assertEquals  import org.junit.Before  import org.junit.Rule  import org.junit.Test  import org.mockito.kotlin.mock  import org.mockito.kotlin.whenever  class UserViewModelTest {     @get:Rule     val instantTaskExecutorRule = InstantTaskExecutorRule()     private lateinit var userRepositoryMock: UserRepository     private lateinit var userViewModel: UserViewModel     @Before     fun setUp() {         userRepositoryMock = mock()         userViewModel = UserViewModel(userRepositoryMock)     }     @Test     fun getAllUsers should return empty list when no users are in database() = runBlockingTest {         // Given         val emptyUserList = listOf<User>()         whenever(userRepositoryMock.getAllUsers()).thenReturn(emptyFlow())         // When         val users = userViewModel.users.first()         // Then         assertEquals(emptyUserList, users)     }     @Test     fun getAllUsers should return list of users when there are users in database() = runBlockingTest {         // Given         val userList = listOf(User(uid = 1, firstName = "John", lastName = "Doe", email =    "john.doe@example.com"))         whenever(userRepositoryMock.getAllUsers()).thenReturn(flowOf(userList))         // When         val users = userViewModel.users.first()         // Then         assertEquals(userList, users)     }     private fun flowOf(list: List<User>): Flow<List<User>> {         return flow {             emit(list)         }     }     private fun emptyFlow(): Flow<List<User>> {         return flow {}     }  }  ```  ### Объяснение тестов  1. Тест на пустой список пользователей: Мы проверяем, что при отсутствии данных в базе, UserViewModel    корректно возвращает пустой список.  2. Тест на заполненный список пользователей: В этом тесте мы подменяем реальный поток данных из базы на    мок-поток с конкретными данными и проверяем, что UserViewModel правильно обрабатывает эти данные.  ### Шаг 3: Дополнительные тесты  Мы также можем добавить тесты для работы с ошибками:  ```kotlin  @Test  fun getAllUsers should throw exception when repository throws an error() = runBlockingTest {     // Given     whenever(userRepositoryMock.getAllUsers()).doReturn(emptyFlow())     // When & Then     assertFailsWith<Throwable> {         userViewModel.users.first()     }  }  ```  ### Замечания  - Обработка ошибок: Добавьте обработку ошибок в ваш UserViewModel, чтобы корректно уведомлять    пользователей о возможных проблемах с базой данных.      - Использование TestCoroutineDispatcher: Для более сложного тестирования вы можете использовать    TestCoroutineDispatcher для контроля выполнения корутин.  ```kotlin  private val testDispatcher = TestCoroutineDispatcher()  @Before  fun setup() {     Dispatchers.setMain(testDispatcher)  }  @AfterEach  fun teardown() {     testDispatcher.cleanupTestCoroutines()  }  ```  Эти тесты помогут вам убедиться, что UserViewModel работает корректно с использованием потоков данных и    корутин.

Для написания юнит-тестов для UserViewModel, которые включают работу с корутинами, Flow` и обработку ошибок, мы начнем с создания мока (например, используя библиотеку Mockito или MockK)  для UserDao. Затем напишем тесты, чтобы покрыть основные функциональности ViewModel.  ### Шаг 1: Подготовка зависимостей и настройка окружения  Убедитесь, что у вас есть необходимые зависимости в вашем build.gradle файле:  ```groovy  dependencies {      implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"      implementation "androidx.room:room-runtime:$room_version"      kapt "androidx.room:room-compiler:$room_version"      testImplementation 'junit:junit:4.13.2'      testImplementation "org.mockito:mockito-core:4.x.x"      testImplementation "io.mockk:mockk:1.12.x"      testImplementation "androidx.arch.core:core-testing:2.1.0" // Для тестирования корутин и Flow  }  ```  ### Шаг 2: Создание ViewModel  Предположим, у нас есть UserViewModel, которая использует Flow для получения данных из базы:  ```kotlin  import androidx.lifecycle.ViewModel  import androidx.lifecycle.viewModelScope  import kotlinx.coroutines.flow.*  import kotlinx.coroutines.launch  class UserViewModel(private val userDao: UserDao) : ViewModel() {      val users = userDao.getAll().catch { e ->          emit(emptyList()) // Логика обработки ошибок      }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())      fun loadUsersByIds(userIds: IntArray) {          viewModelScope.launch {              try {                  userDao.loadAllByIds(userIds).collect { users ->                      // Обработка списка пользователей по ID                  }              } catch (e: Exception) {                  // Логика обработки ошибок              }          }      }      fun addUser(user: User) = viewModelScope.launch {          try {              userDao.insert(user)          } catch (e: Exception) {              // Обработка исключения          }      }  }  ```  ### Шаг 3: Написание тестов  Теперь мы можем написать юнит-тесты:  ```kotlin  import kotlinx.coroutines.ExperimentalCoroutinesApi  import kotlinx.coroutines.flow.flowOf  import kotlinx.coroutines.test.runTest  import org.junit.Assert.assertEquals  import org.junit.Before  import org.junit.Test  import org.mockito.kotlin.*  @OptIn(ExperimentalCoroutinesApi::class)  class UserViewModelTest {      private lateinit var userDao: UserDao      private lateinit var viewModel: UserViewModel      @Before      fun setUp() {          userDao = mock()          viewModel = UserViewModel(userDao)      }      @Test      fun test getAll users() = runTest {          val userList = listOf(User(1, "John", "Doe", "john@doe.com"))          whenever(userDao.getAll()).thenReturn(flowOf(userList))          assertEquals(userList, viewModel.users.first())      }      @Test      fun test loadUsersByIds success() = runTest {          val userIds = intArrayOf(1, 2)          val userList = listOf(User(1, "Jane", "Doe", "jane@doe.com"), User(2, "Bob", "Smith", "bob@smith.com"))          whenever(userDao.loadAllByIds(any())).thenReturn(flowOf(userList))          viewModel.loadUsersByIds(userIds)          // Проверка того, что корутинная логика сработала корректно      }      @Test      fun test getAll error handling() = runTest {          val exception = Exception("Database error")          whenever(userDao.getAll()).thenReturn(flow { throw exception })          assertEquals(emptyList<User>(), viewModel.users.first())      }      @Test      fun test addUser success() = runTest {          val user = User(3, "Alice", "Johnson", "alice@johnson.com")          viewModel.addUser(user)          verify(userDao).insert(user)      }      @Test      fun test addUser error handling() = runTest {          val user = User(4, "Charlie", "Brown", "charlie@brown.com")          whenever(userDao.insert(any())).thenThrow(RuntimeException("Insert failed"))          viewModel.addUser(user)          // Проверить логику обработки ошибок      }  }  ```  ### Объяснение  1. runTest: Используется для тестирования корутинных функций в изолированной среде.  2. Mocking: Мы используем mockk для создания мока объекта UserDao, чтобы проверить, как ViewModel взаимодействует с ним.  3. Error handling: Проверяем, что ошибка корректно обрабатывается и заменяется на пустой список или другое подходящее значение.  Таким образом мы обеспечиваем покрытие основных функциональностей ViewModel через тесты.