evp-comm-server/src/test/java/com/evp/comm/server/EvpCommServerApplicationTests.java

package com.evp.comm.server;

import com.evp.app.common.utils.ByteUtils;
import com.evp.app.common.utils.SysUtils;
import com.evp.app.common.utils.TimeUtils;
import com.evp.comm.server.dto.EvpsCenter;
import com.evp.comm.server.dto.NetState;
import com.evp.comm.server.kafka.KafkaProducerService;
import com.evp.comm.server.kafka.dto.KafkaEvpsServiceDto;
import com.evp.comm.server.xnet.server.process.protocol.EvpsProtocolConst;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.TimeZone;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Slf4j
@SpringBootTest
public class EvpCommServerApplicationTests {

    public static final EvpsCenter rCenter = EvpsCenter.builder()
            .idx(0)
            .centerId("L01")
            .centerNm("UTIC SIGNAL 센터")
            .ipAddress("127.0.0.1")
            .netState(new NetState())
            .useYn(true)
            .dump(false)
            .build();

    @Autowired
    private KafkaProducerService kafkaService;
    public static String toString( Date date ) {

        SimpleDateFormat df = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );

        TimeZone tz = TimeZone.getTimeZone( "UTC" );

        df.setTimeZone( tz );

        String output = df.format( date );

        int inset0 = 9;
        int inset1 = 6;

        String s0 = output.substring( 0, output.length() - inset0 );
        String s1 = output.substring( output.length() - inset1, output.length() );

        String result = s0 + s1;

        result = result.replaceAll( "UTC", "+00:00" );

        return result;

    }

    @Test
    void testDate() {
        log.info("{}", toString(new Date()));
        log.info("{}", TimeUtils.now());
    }
    @Test
    void sendTopicService() {
        KafkaEvpsServiceDto data = KafkaEvpsServiceDto.builder()
                .serviceId("99920240906124848")
                //.clctDt(TimeUtils.getCurrentDate())
                .evNo("373구2164")
                .curLat(1.)
                .curLng(2.)
                .serviceNm("도로교통공단")
                .arrLat(3.)
                .arrLng(4.)
                .arrTm(10)
                .vehLen(20)
                .ocrNo("")
                .ocrType("")
                .serviceDist(4300)
                .statusCd(1)
                .routeList(new ArrayList<>())
                .build();
        kafkaService.sendEvpsServiceTopic(data);
    }

    @Test
    void test3() {
        String data = "000102030405060708090A000102030405060708090A000102030405060708090A";
        byte[] inBytes = ByteUtils.hexToByteArray(data);
        ByteBuf byteBuf = Unpooled.copiedBuffer(inBytes);
        log.info("readableBytes: {}", byteBuf.readableBytes());
        log.info("readerIndex: {}", byteBuf.readerIndex());
        byte[] buffer = new byte[EvpsProtocolConst.EVPS_HEAD_SIZE];
        byteBuf.getBytes(0, buffer);
        log.info("buffer: {}", SysUtils.byteArrayToHex(buffer));

        byte[] buffer2 = new byte[inBytes.length - EvpsProtocolConst.EVPS_HEAD_SIZE];
        byteBuf.getBytes(EvpsProtocolConst.EVPS_HEAD_SIZE, buffer2);
        log.info("buffer: {}", SysUtils.byteArrayToHex(buffer2));

        log.info("readableBytes: {}", byteBuf.readableBytes());
        log.info("readerIndex: {}", byteBuf.readerIndex());
    }
    @Test
    void testDecompress() {
        //ReadableBytes: 113 Bytes
        String data = "02C518081A01061A11571DB1020C00020003010004006C00001900C800400200140050088040000802A0040021001001408100020C10608000010808A0000000000000000000000000000000000000000000000000000000000000000000000000000001FFC234B7EEAFFBEBB2EDEFFF0C123C030A1E020307140203020C1B320203000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003010104006C00008128084441200A0451508882401408A2A0000001001000400102021010808000040820A0000000000000000000000000000000000000000000000000000000000000000000000000000001FF020303030B0C5CEDAFBBFB3BFF0C123C030A1E03071403020C1B32020300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E803";
        byte[] inBytes = ByteUtils.hexToByteArray(data);
        log.error("Packet Length: {}", inBytes.length);
//        EvpsCommPacket evpsCommPacket = new EvpsCommPacket(rCenter, inBytes);
//        RecvPacketDto packet = RecvPacketDto.builder()
//                .recvTime(0)
//                .center(rCenter)
//                .packet(evpsCommPacket)
//                .build();
        //EvpsSignalMap response = new EvpsSignalMap(null);
//        response.responseTEST(packet);
    }


    @Test
    void tt() {
        for (int ii = 0; ii < 608; ii++) {
            log.info("{}, {}, {}", ii, ii/19, ii%19);
        }
    }
    @Test
    void testDecompress2010() {
        //ReadableBytes: 113 Bytes
        String data = "02C518081901061911551DB1020C000200010200030036E04BC31020DDC10105E021C11020E030C80102D8C10105C2C10105E039C8010200555C9C2503000102090F3C090F3C010C1246006C2400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010201030025E041C80102E0B7C80102E021C5102000555C9C2503000102090F3C090F3C01040546003E450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000AB03";
        byte[] inBytes = ByteUtils.hexToByteArray(data);
        log.error("Packet Length: {}", inBytes.length);
//        EvpsCommPacket evpsCommPacket = new EvpsCommPacket(rCenter, inBytes);
//        RecvPacketDto packet = RecvPacketDto.builder()
//                .recvTime(0)
//                .center(rCenter)
//                .packet(evpsCommPacket)
//                .build();
//        EvpsSignalMap response = new EvpsSignalMap(null);
//        response.responseTEST(packet);
    }


    @Test
    public void test() {
        //1720599437901
        //1720599437
        //106844625303900
        long start = System.currentTimeMillis();
        log.error("[{}, {}, {}]", start, TimeUnit.SECONDS.convert(start, TimeUnit.MILLISECONDS), System.nanoTime());
    }
    @Test
    public void test1() {
        String hostName;
        String hostAddress;
        try {
            InetAddress localhost = InetAddress.getLocalHost();
            hostName = localhost.getHostName();
            hostAddress = localhost.getHostAddress();
        } catch (UnknownHostException e) {
            hostName = "localhost";
            hostAddress = "127.0.0.1";
        }
        System.out.println("Your current IP address : " + hostAddress);
        System.out.println("Your current Hostname : " + hostName);

        InetAddress ip;
        String hostname;
        try {
            ip = InetAddress.getLocalHost();
            hostname = ip.getHostName();
            System.out.println("Your current IP address : " + ip);
            System.out.println("Your current Hostname : " + hostname);

        } catch (UnknownHostException e) {

            e.printStackTrace();
        }
    }
    class WorkerThreadTask implements Runnable {

        private ThreadPoolExecutor processExecutor;

        public WorkerThreadTask(ThreadPoolExecutor processExecutor, int idx) {
            Thread.currentThread().setName(String.format("worker-pool-%02d", idx));
            this.processExecutor = processExecutor;
        }

        @Override
        public void run() {
            while (true) {
                log.error("{}, corePoolSize: {}, activeCount: {}, maximumPoolSize: {}, poolSize: {}, taskCount: {}",
                        Thread.currentThread().getName(),
                        processExecutor.getCorePoolSize(),
                        processExecutor.getActiveCount(),
                        processExecutor.getMaximumPoolSize(),
                        processExecutor.getPoolSize(),
                        processExecutor.getTaskCount());
                try {
                    Thread.sleep(1000);
                    if (processExecutor.awaitTermination(1L, TimeUnit.MILLISECONDS))
                        log.info("Terminated");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    class NamedThreadsFactory implements ThreadFactory {

        private int count = 0;
        private String Name = "MyThread-";

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, Name + ++count); // Mythread-x 형태로 쓰레드 이름 설정
        }
    }

    @Test
    public void testThread() throws InterruptedException {
        int threadPoolSize = Runtime.getRuntime().availableProcessors() * 10;
        ThreadPoolExecutor processExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
        log.info("corePoolSize: {}, activeCount: {}, maximumPoolSize: {}, poolSize: {}, taskCount: {}",
                processExecutor.getCorePoolSize(),
                processExecutor.getActiveCount(),
                processExecutor.getMaximumPoolSize(),
                processExecutor.getPoolSize(),
                processExecutor.getTaskCount());

        for (int ii = 0; ii < threadPoolSize; ii++) {
            log.info("Thread Start: {}", ii);
            processExecutor.execute(new WorkerThreadTask(processExecutor, ii));
            /*processExecutor.execute(() -> {
                while (true) {
                    try {
                        log.error("{}, corePoolSize: {}, activeCount: {}, maximumPoolSize: {}, poolSize: {}, taskCount: {}",
                                Thread.currentThread().getName(),
                                processExecutor.getCorePoolSize(),
                                processExecutor.getActiveCount(),
                                processExecutor.getMaximumPoolSize(),
                                processExecutor.getPoolSize(),
                                processExecutor.getTaskCount());
                        Thread.sleep(1000);
                    }
                    catch (Exception e) {
                        log.error("{}", e.getMessage(), e);
                    }
                }
            });*/
        }
        Thread.sleep(20000);
    }

    @Test
    public void checkSumTest() {

    }

}