Explain the logic of these dates which are used to get the previous year first and last dates

DECLARE @FromTestDate Datetime
DECLARE @ToTestDate Datetime
DECLARE @FromDate DATETIME
DECLARE @ToDate DATETIME

SET @FromTestDate= DATEDIFF(yy,0,GETDATE())
SELECT @FromTestDate AS FromTestDate

SET @FromDate = DATEADD(yy, datediff(yy, 0, GETDATE())-1, 0) 
--@FromDate should be (CurrentDate + From TestDate -- 3800-06-04)
SELECT @FromDate As FromDate 

SET @ToTestDate= DATEDIFF(yy,30,GETDATE())
SELECT @ToTestDate AS ToTestDate

SET @ToDate = DATEADD(yy, DATEDIFF(yy, 0, GETDATE()), -1)   
SELECT @ToDate AS ToDate

This is the logic we use to calculate the previous year first and last dates. I am new to SQL and as per dateadd() functionality it would add the dates and @FromDate should be (CurrentDate + From TestDate -- 3800-06-04) but it is behaving differently and providing what is expected. I just want to understand the logic behind it.

Expecting the analysis

I have no idea if anyone can (or should) reverse engineer that spaghetti. These things are so much easier to express. You don't need to test anything, come up with arbitrary dates, etc.

-- If we just take *last* year into a variable:

DECLARE @LastYear int = DATEPART(YEAR, getdate()) - 1;

-- First day of last year is:

SELECT FromDate = DATEFROMPARTS(@LastYear, 1, 1);

-- Last day of last year is:

SELECT ToDate = DATEFROMPARTS(@LastYear, 12, 31));

• Working example in this db<>fiddle.

All this datediff from zero nonsense is the kind of thing we had to do in SQL Server 2005, but we shouldn't be doing it anymore. And using yy instead of spelling out YEAR is just... being cryptic for fun? Please read through all the links at Dating Responsibly.

Anyway, to answer the question asked ("please explain this spaghetti"):

DECLARE @FromTestDate Datetime
DECLARE @ToTestDate Datetime
DECLARE @FromDate DATETIME
DECLARE @ToDate DATETIME
  SET @FromTestDate= DATEDIFF(yy,0,GETDATE())

This is just wrong. On the right-hand side we calculate the difference in yys (better known as years) between 0 (which is a lazy/cryptic way to express 1900-01-01). This answer yields, well, for the rest of this year at least, 123. When we assign that to a datetime, though, we are saying "add 123 days to 0" (which, again, is 1900-01-01):

DECLARE @d datetime = 123;
SELECT @d;

-- result:
1900-05-04 00:00:00.000

123 days after 1900-01-01 is May the 4th be with you of that same year.

Tip: Taking the datediff from 0 to {now} only works for determining a datetime if you are taking the datediff in days. If you are taking the datediff in years, for example, it can only be used to indicate the number of years that have passed.^* Point is, you can't assign a number of years to a datetime and expect it to yield the right datetime, because it will take that number that you intend to mean years and add that many days to 1900-01-01.

Next we have:

SET @FromDate = DATEADD(yy, datediff(yy, 0, GETDATE())-1, 0) 

This is saying (again, incorrectly) "take the difference in years between 0 (1900-01-01) and today, subtract one, and then add that many years to 0 (1900-01-01). This actually works because we are using the output (an integer, not a datetime) to add years to another date. But as I describe above, this is a really messy way to express that.

  --@FromDate should be (CurrentDate + From TestDate -- 3800-06-04)

I'm not sure what this comment is supposed to mean. Adding today to today doesn't double today and make it sometime in April, 4046. So not sure how you got the year 3800 there.

Next:

  SET @ToTestDate= DATEDIFF(yy,30,GETDATE())

Well, this doesn't make sense. We're again trying to assign to a datetime an integer value that is attempting to, I'm not sure, maybe add 30 years to today? As written, this actually says "how many years have passed since 30 (which is 30 days after 0 (1900-01-01)). Showing it in steps:

DECLARE @i int = DATEDIFF(yy, 30, GETDATE());
SELECT @i; -- 123

DECLARE @d datetime = DATEDIFF(yy, 30, GETDATE());
SELECT @d; -- 1900-05-04 00:00:00.000

-- which is the same as
DECLARE @x datetime = 123;

Last:

  SET @ToDate = DATEADD(yy, DATEDIFF(yy, 0, GETDATE()), -1) 

This one is even more cryptic and a funny coincidence that it actually works. This says take the number of years that have passed since 0 (1900-01-01), and add that many years to -1. -1 is, you may have guessed, one day before 1900-01-01, 1899-12-31. So adding the number of years that have passed since 1900 to the day before Jan 1, 1900 just happens to work out, when I think the author expected that to work because they thought they were saying "add one less year than the number of years that have passed."

^* To be more accurate, the number of year boundaries that have passed. These yield the same answer (1), even though in one case almost two years have passed, and in the other, only one day has passed:

SELECT DATEDIFF(YEAR, '20210101', '20221231'),
       DATEDIFF(YEAR, '20211231', '20220101');